cx_api/generated/
com.coralogix.archive.v1.rs

1// This file is @generated by prost-build.
2#[derive(serde::Serialize, serde::Deserialize)]
3#[serde(rename_all = "snake_case")]
4#[derive(Clone, PartialEq, ::prost::Message)]
5pub struct Retention {
6    #[prost(message, optional, tag = "1")]
7    pub id: ::core::option::Option<::prost::alloc::string::String>,
8    #[prost(message, optional, tag = "2")]
9    pub order: ::core::option::Option<i32>,
10    #[prost(message, optional, tag = "3")]
11    pub name: ::core::option::Option<::prost::alloc::string::String>,
12    #[prost(message, optional, tag = "4")]
13    pub editable: ::core::option::Option<bool>,
14}
15#[derive(serde::Serialize, serde::Deserialize)]
16#[serde(rename_all = "snake_case")]
17#[derive(Clone, Copy, PartialEq, ::prost::Message)]
18pub struct GetRetentionsRequest {}
19#[derive(serde::Serialize, serde::Deserialize)]
20#[serde(rename_all = "snake_case")]
21#[derive(Clone, PartialEq, ::prost::Message)]
22pub struct GetRetentionsResponse {
23    #[prost(message, repeated, tag = "1")]
24    pub retentions: ::prost::alloc::vec::Vec<Retention>,
25}
26#[derive(serde::Serialize, serde::Deserialize)]
27#[serde(rename_all = "snake_case")]
28#[derive(Clone, PartialEq, ::prost::Message)]
29pub struct RetentionUpdateElement {
30    #[prost(message, optional, tag = "1")]
31    pub id: ::core::option::Option<::prost::alloc::string::String>,
32    #[prost(message, optional, tag = "2")]
33    pub name: ::core::option::Option<::prost::alloc::string::String>,
34}
35#[derive(serde::Serialize, serde::Deserialize)]
36#[serde(rename_all = "snake_case")]
37#[derive(Clone, PartialEq, ::prost::Message)]
38pub struct UpdateRetentionsRequest {
39    #[prost(message, repeated, tag = "1")]
40    pub retention_update_elements: ::prost::alloc::vec::Vec<RetentionUpdateElement>,
41}
42#[derive(serde::Serialize, serde::Deserialize)]
43#[serde(rename_all = "snake_case")]
44#[derive(Clone, PartialEq, ::prost::Message)]
45pub struct UpdateRetentionsResponse {
46    #[prost(message, repeated, tag = "1")]
47    pub retentions: ::prost::alloc::vec::Vec<Retention>,
48}
49#[derive(serde::Serialize, serde::Deserialize)]
50#[serde(rename_all = "snake_case")]
51#[derive(Clone, Copy, PartialEq, ::prost::Message)]
52pub struct ActivateRetentionsRequest {}
53#[derive(serde::Serialize, serde::Deserialize)]
54#[serde(rename_all = "snake_case")]
55#[derive(Clone, Copy, PartialEq, ::prost::Message)]
56pub struct ActivateRetentionsResponse {
57    #[prost(message, optional, tag = "1")]
58    pub activate_retentions: ::core::option::Option<bool>,
59}
60#[derive(serde::Serialize, serde::Deserialize)]
61#[serde(rename_all = "snake_case")]
62#[derive(Clone, Copy, PartialEq, ::prost::Message)]
63pub struct GetRetentionsEnabledRequest {}
64#[derive(serde::Serialize, serde::Deserialize)]
65#[serde(rename_all = "snake_case")]
66#[derive(Clone, Copy, PartialEq, ::prost::Message)]
67pub struct GetRetentionsEnabledResponse {
68    #[prost(message, optional, tag = "1")]
69    pub enable_tags: ::core::option::Option<bool>,
70}
71/// Generated client implementations.
72pub mod retentions_service_client {
73    #![allow(
74        unused_variables,
75        dead_code,
76        missing_docs,
77        clippy::wildcard_imports,
78        clippy::let_unit_value,
79    )]
80    use tonic::codegen::*;
81    use tonic::codegen::http::Uri;
82    #[derive(Debug, Clone)]
83    pub struct RetentionsServiceClient<T> {
84        inner: tonic::client::Grpc<T>,
85    }
86    impl RetentionsServiceClient<tonic::transport::Channel> {
87        /// Attempt to create a new client by connecting to a given endpoint.
88        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
89        where
90            D: TryInto<tonic::transport::Endpoint>,
91            D::Error: Into<StdError>,
92        {
93            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
94            Ok(Self::new(conn))
95        }
96    }
97    impl<T> RetentionsServiceClient<T>
98    where
99        T: tonic::client::GrpcService<tonic::body::BoxBody>,
100        T::Error: Into<StdError>,
101        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
102        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
103    {
104        pub fn new(inner: T) -> Self {
105            let inner = tonic::client::Grpc::new(inner);
106            Self { inner }
107        }
108        pub fn with_origin(inner: T, origin: Uri) -> Self {
109            let inner = tonic::client::Grpc::with_origin(inner, origin);
110            Self { inner }
111        }
112        pub fn with_interceptor<F>(
113            inner: T,
114            interceptor: F,
115        ) -> RetentionsServiceClient<InterceptedService<T, F>>
116        where
117            F: tonic::service::Interceptor,
118            T::ResponseBody: Default,
119            T: tonic::codegen::Service<
120                http::Request<tonic::body::BoxBody>,
121                Response = http::Response<
122                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
123                >,
124            >,
125            <T as tonic::codegen::Service<
126                http::Request<tonic::body::BoxBody>,
127            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
128        {
129            RetentionsServiceClient::new(InterceptedService::new(inner, interceptor))
130        }
131        /// Compress requests with the given encoding.
132        ///
133        /// This requires the server to support it otherwise it might respond with an
134        /// error.
135        #[must_use]
136        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
137            self.inner = self.inner.send_compressed(encoding);
138            self
139        }
140        /// Enable decompressing responses.
141        #[must_use]
142        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
143            self.inner = self.inner.accept_compressed(encoding);
144            self
145        }
146        /// Limits the maximum size of a decoded message.
147        ///
148        /// Default: `4MB`
149        #[must_use]
150        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
151            self.inner = self.inner.max_decoding_message_size(limit);
152            self
153        }
154        /// Limits the maximum size of an encoded message.
155        ///
156        /// Default: `usize::MAX`
157        #[must_use]
158        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
159            self.inner = self.inner.max_encoding_message_size(limit);
160            self
161        }
162        pub async fn get_retentions(
163            &mut self,
164            request: impl tonic::IntoRequest<super::GetRetentionsRequest>,
165        ) -> std::result::Result<
166            tonic::Response<super::GetRetentionsResponse>,
167            tonic::Status,
168        > {
169            self.inner
170                .ready()
171                .await
172                .map_err(|e| {
173                    tonic::Status::unknown(
174                        format!("Service was not ready: {}", e.into()),
175                    )
176                })?;
177            let codec = tonic::codec::ProstCodec::default();
178            let path = http::uri::PathAndQuery::from_static(
179                "/com.coralogix.archive.v1.RetentionsService/GetRetentions",
180            );
181            let mut req = request.into_request();
182            req.extensions_mut()
183                .insert(
184                    GrpcMethod::new(
185                        "com.coralogix.archive.v1.RetentionsService",
186                        "GetRetentions",
187                    ),
188                );
189            self.inner.unary(req, path, codec).await
190        }
191        pub async fn update_retentions(
192            &mut self,
193            request: impl tonic::IntoRequest<super::UpdateRetentionsRequest>,
194        ) -> std::result::Result<
195            tonic::Response<super::UpdateRetentionsResponse>,
196            tonic::Status,
197        > {
198            self.inner
199                .ready()
200                .await
201                .map_err(|e| {
202                    tonic::Status::unknown(
203                        format!("Service was not ready: {}", e.into()),
204                    )
205                })?;
206            let codec = tonic::codec::ProstCodec::default();
207            let path = http::uri::PathAndQuery::from_static(
208                "/com.coralogix.archive.v1.RetentionsService/UpdateRetentions",
209            );
210            let mut req = request.into_request();
211            req.extensions_mut()
212                .insert(
213                    GrpcMethod::new(
214                        "com.coralogix.archive.v1.RetentionsService",
215                        "UpdateRetentions",
216                    ),
217                );
218            self.inner.unary(req, path, codec).await
219        }
220        pub async fn activate_retentions(
221            &mut self,
222            request: impl tonic::IntoRequest<super::ActivateRetentionsRequest>,
223        ) -> std::result::Result<
224            tonic::Response<super::ActivateRetentionsResponse>,
225            tonic::Status,
226        > {
227            self.inner
228                .ready()
229                .await
230                .map_err(|e| {
231                    tonic::Status::unknown(
232                        format!("Service was not ready: {}", e.into()),
233                    )
234                })?;
235            let codec = tonic::codec::ProstCodec::default();
236            let path = http::uri::PathAndQuery::from_static(
237                "/com.coralogix.archive.v1.RetentionsService/ActivateRetentions",
238            );
239            let mut req = request.into_request();
240            req.extensions_mut()
241                .insert(
242                    GrpcMethod::new(
243                        "com.coralogix.archive.v1.RetentionsService",
244                        "ActivateRetentions",
245                    ),
246                );
247            self.inner.unary(req, path, codec).await
248        }
249        pub async fn get_retentions_enabled(
250            &mut self,
251            request: impl tonic::IntoRequest<super::GetRetentionsEnabledRequest>,
252        ) -> std::result::Result<
253            tonic::Response<super::GetRetentionsEnabledResponse>,
254            tonic::Status,
255        > {
256            self.inner
257                .ready()
258                .await
259                .map_err(|e| {
260                    tonic::Status::unknown(
261                        format!("Service was not ready: {}", e.into()),
262                    )
263                })?;
264            let codec = tonic::codec::ProstCodec::default();
265            let path = http::uri::PathAndQuery::from_static(
266                "/com.coralogix.archive.v1.RetentionsService/GetRetentionsEnabled",
267            );
268            let mut req = request.into_request();
269            req.extensions_mut()
270                .insert(
271                    GrpcMethod::new(
272                        "com.coralogix.archive.v1.RetentionsService",
273                        "GetRetentionsEnabled",
274                    ),
275                );
276            self.inner.unary(req, path, codec).await
277        }
278    }
279}