1#[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}
71pub 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 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 #[must_use]
136 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
137 self.inner = self.inner.send_compressed(encoding);
138 self
139 }
140 #[must_use]
142 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
143 self.inner = self.inner.accept_compressed(encoding);
144 self
145 }
146 #[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 #[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}