cx_api/generated/
com.coralogixapis.alerting.alert_scheduler_rule_protobuf.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 Filter {
6    /// Filter what_expression: dataprime expression that filter the alerts group by values.
7    #[prost(string, tag = "1")]
8    pub what_expression: ::prost::alloc::string::String,
9    #[prost(oneof = "filter::WhichAlerts", tags = "2, 3")]
10    pub which_alerts: ::core::option::Option<filter::WhichAlerts>,
11}
12/// Nested message and enum types in `Filter`.
13pub mod filter {
14    #[derive(serde::Serialize, serde::Deserialize)]
15    #[serde(rename_all = "snake_case")]
16    #[derive(Clone, PartialEq, ::prost::Oneof)]
17    pub enum WhichAlerts {
18        /// Filter alert_meta_labels: filter alerts by meta labels tagging.
19        #[prost(message, tag = "2")]
20        AlertMetaLabels(super::MetaLabels),
21        /// Filter alert_unique_ids: filter specific alerts (when alert_unique_ids is empty meaning it wil filter all alerts).
22        #[prost(message, tag = "3")]
23        AlertUniqueIds(super::AlertUniqueIds),
24    }
25}
26#[derive(serde::Serialize, serde::Deserialize)]
27#[serde(rename_all = "snake_case")]
28#[derive(Clone, PartialEq, ::prost::Message)]
29pub struct AlertUniqueIds {
30    #[prost(string, repeated, tag = "1")]
31    pub value: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
32}
33#[derive(serde::Serialize, serde::Deserialize)]
34#[serde(rename_all = "snake_case")]
35#[derive(Clone, PartialEq, ::prost::Message)]
36pub struct MetaLabels {
37    #[prost(message, repeated, tag = "1")]
38    pub value: ::prost::alloc::vec::Vec<
39        super::super::meta_labels_protobuf::v1::MetaLabel,
40    >,
41}
42#[derive(serde::Serialize, serde::Deserialize)]
43#[serde(rename_all = "snake_case")]
44#[derive(Clone, PartialEq, ::prost::Message)]
45pub struct Timeframe {
46    /// Timeframe start time: The point in the time(date-time) when the rule will start to be active.
47    #[prost(string, tag = "1")]
48    pub start_time: ::prost::alloc::string::String,
49    /// Timeframe timezone: The rule will be active according to a specific timezone.
50    #[prost(string, tag = "4")]
51    pub timezone: ::prost::alloc::string::String,
52    #[prost(oneof = "timeframe::Until", tags = "2, 3")]
53    pub until: ::core::option::Option<timeframe::Until>,
54}
55/// Nested message and enum types in `Timeframe`.
56pub mod timeframe {
57    #[derive(serde::Serialize, serde::Deserialize)]
58    #[serde(rename_all = "snake_case")]
59    #[derive(Clone, PartialEq, ::prost::Oneof)]
60    pub enum Until {
61        /// Timeframe end time: The point in the time(date-time) when the rule will finish to be active.
62        #[prost(string, tag = "2")]
63        EndTime(::prost::alloc::string::String),
64        /// Timeframe duration: The duration interval of the rule activation.
65        #[prost(message, tag = "3")]
66        Duration(super::Duration),
67    }
68}
69#[derive(serde::Serialize, serde::Deserialize)]
70#[serde(rename_all = "snake_case")]
71#[derive(Clone, Copy, PartialEq, ::prost::Message)]
72pub struct Duration {
73    /// Duration for_over: The duration interval.
74    #[prost(int32, tag = "1")]
75    pub for_over: i32,
76    /// Duration frequency: The duration frequency types (minute hour or day).
77    #[prost(enumeration = "DurationFrequency", tag = "2")]
78    pub frequency: i32,
79}
80#[derive(serde::Serialize, serde::Deserialize)]
81#[serde(rename_all = "snake_case")]
82#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
83#[repr(i32)]
84pub enum DurationFrequency {
85    Unspecified = 0,
86    Minute = 1,
87    Hour = 2,
88    Day = 3,
89}
90impl DurationFrequency {
91    /// String value of the enum field names used in the ProtoBuf definition.
92    ///
93    /// The values are not transformed in any way and thus are considered stable
94    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
95    pub fn as_str_name(&self) -> &'static str {
96        match self {
97            Self::Unspecified => "DURATION_FREQUENCY_UNSPECIFIED",
98            Self::Minute => "DURATION_FREQUENCY_MINUTE",
99            Self::Hour => "DURATION_FREQUENCY_HOUR",
100            Self::Day => "DURATION_FREQUENCY_DAY",
101        }
102    }
103    /// Creates an enum from field names used in the ProtoBuf definition.
104    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
105        match value {
106            "DURATION_FREQUENCY_UNSPECIFIED" => Some(Self::Unspecified),
107            "DURATION_FREQUENCY_MINUTE" => Some(Self::Minute),
108            "DURATION_FREQUENCY_HOUR" => Some(Self::Hour),
109            "DURATION_FREQUENCY_DAY" => Some(Self::Day),
110            _ => None,
111        }
112    }
113}
114#[derive(serde::Serialize, serde::Deserialize)]
115#[serde(rename_all = "snake_case")]
116#[derive(Clone, PartialEq, ::prost::Message)]
117pub struct Schedule {
118    /// Rule schedule_operation: The rule operation mode (mute/active).
119    #[prost(enumeration = "ScheduleOperation", tag = "1")]
120    pub schedule_operation: i32,
121    #[prost(oneof = "schedule::Scheduler", tags = "2, 3")]
122    pub scheduler: ::core::option::Option<schedule::Scheduler>,
123}
124/// Nested message and enum types in `Schedule`.
125pub mod schedule {
126    #[derive(serde::Serialize, serde::Deserialize)]
127    #[serde(rename_all = "snake_case")]
128    #[derive(Clone, PartialEq, ::prost::Oneof)]
129    pub enum Scheduler {
130        /// Schedule one_time: The scheduling definition will activate the rule for a specific timeframe.
131        #[prost(message, tag = "2")]
132        OneTime(super::OneTime),
133        /// Schedule recurring: The scheduling definition will activate the rule for a recurring timeframe.
134        #[prost(message, tag = "3")]
135        Recurring(super::Recurring),
136    }
137}
138#[derive(serde::Serialize, serde::Deserialize)]
139#[serde(rename_all = "snake_case")]
140#[derive(Clone, PartialEq, ::prost::Message)]
141pub struct OneTime {
142    #[prost(message, optional, tag = "1")]
143    pub timeframe: ::core::option::Option<Timeframe>,
144}
145#[derive(serde::Serialize, serde::Deserialize)]
146#[serde(rename_all = "snake_case")]
147#[derive(Clone, PartialEq, ::prost::Message)]
148pub struct Recurring {
149    #[prost(oneof = "recurring::Condition", tags = "1, 2")]
150    pub condition: ::core::option::Option<recurring::Condition>,
151}
152/// Nested message and enum types in `Recurring`.
153pub mod recurring {
154    #[derive(serde::Serialize, serde::Deserialize)]
155    #[serde(rename_all = "snake_case")]
156    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
157    pub struct Always {}
158    #[derive(serde::Serialize, serde::Deserialize)]
159    #[serde(rename_all = "snake_case")]
160    #[derive(Clone, PartialEq, ::prost::Message)]
161    pub struct Dynamic {
162        /// Recurring Dynamic repeat_every: The rule will be activated in a recurring mode according to the interval.
163        #[prost(int32, tag = "1")]
164        pub repeat_every: i32,
165        /// Recurring Dynamic timeframe: The rule will be activated in a recurring mode according to the specific timeframe.
166        #[prost(message, optional, tag = "5")]
167        pub timeframe: ::core::option::Option<super::Timeframe>,
168        /// Recurring Dynamic termination_date: The rule will be terminated according to termination_date.
169        #[prost(string, optional, tag = "6")]
170        pub termination_date: ::core::option::Option<::prost::alloc::string::String>,
171        #[prost(oneof = "dynamic::Frequency", tags = "2, 3, 4")]
172        pub frequency: ::core::option::Option<dynamic::Frequency>,
173    }
174    /// Nested message and enum types in `Dynamic`.
175    pub mod dynamic {
176        #[derive(serde::Serialize, serde::Deserialize)]
177        #[serde(rename_all = "snake_case")]
178        #[derive(Clone, PartialEq, ::prost::Oneof)]
179        pub enum Frequency {
180            #[prost(message, tag = "2")]
181            Daily(super::super::Daily),
182            #[prost(message, tag = "3")]
183            Weekly(super::super::Weekly),
184            #[prost(message, tag = "4")]
185            Monthly(super::super::Monthly),
186        }
187    }
188    #[derive(serde::Serialize, serde::Deserialize)]
189    #[serde(rename_all = "snake_case")]
190    #[derive(Clone, PartialEq, ::prost::Oneof)]
191    pub enum Condition {
192        #[prost(message, tag = "1")]
193        Always(Always),
194        #[prost(message, tag = "2")]
195        Dynamic(Dynamic),
196    }
197}
198#[derive(serde::Serialize, serde::Deserialize)]
199#[serde(rename_all = "snake_case")]
200#[derive(Clone, Copy, PartialEq, ::prost::Message)]
201pub struct Daily {}
202#[derive(serde::Serialize, serde::Deserialize)]
203#[serde(rename_all = "snake_case")]
204#[derive(Clone, PartialEq, ::prost::Message)]
205pub struct Weekly {
206    /// Dynamic Weekly days_of_week: The rule will be activated at weekly intervals on specific days in a week.
207    #[prost(int32, repeated, tag = "1")]
208    pub days_of_week: ::prost::alloc::vec::Vec<i32>,
209}
210#[derive(serde::Serialize, serde::Deserialize)]
211#[serde(rename_all = "snake_case")]
212#[derive(Clone, PartialEq, ::prost::Message)]
213pub struct Monthly {
214    /// Dynamic Monthly days_of_month: The rule will be activated at monthly intervals on specific days in a month.
215    #[prost(int32, repeated, tag = "1")]
216    pub days_of_month: ::prost::alloc::vec::Vec<i32>,
217}
218#[derive(serde::Serialize, serde::Deserialize)]
219#[serde(rename_all = "snake_case")]
220#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
221#[repr(i32)]
222pub enum ScheduleOperation {
223    Unspecified = 0,
224    Mute = 1,
225    Activate = 2,
226}
227impl ScheduleOperation {
228    /// String value of the enum field names used in the ProtoBuf definition.
229    ///
230    /// The values are not transformed in any way and thus are considered stable
231    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
232    pub fn as_str_name(&self) -> &'static str {
233        match self {
234            Self::Unspecified => "SCHEDULE_OPERATION_UNSPECIFIED",
235            Self::Mute => "SCHEDULE_OPERATION_MUTE",
236            Self::Activate => "SCHEDULE_OPERATION_ACTIVATE",
237        }
238    }
239    /// Creates an enum from field names used in the ProtoBuf definition.
240    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
241        match value {
242            "SCHEDULE_OPERATION_UNSPECIFIED" => Some(Self::Unspecified),
243            "SCHEDULE_OPERATION_MUTE" => Some(Self::Mute),
244            "SCHEDULE_OPERATION_ACTIVATE" => Some(Self::Activate),
245            _ => None,
246        }
247    }
248}
249#[derive(serde::Serialize, serde::Deserialize)]
250#[serde(rename_all = "snake_case")]
251#[derive(Clone, PartialEq, ::prost::Message)]
252pub struct AlertSchedulerRule {
253    /// Rule unique_identifier: The rule id.
254    #[prost(string, optional, tag = "1")]
255    pub unique_identifier: ::core::option::Option<::prost::alloc::string::String>,
256    /// Rule id: The rule version id.
257    #[prost(string, optional, tag = "2")]
258    pub id: ::core::option::Option<::prost::alloc::string::String>,
259    /// Rule name.
260    #[prost(string, tag = "3")]
261    pub name: ::prost::alloc::string::String,
262    /// Rule description.
263    #[prost(string, optional, tag = "4")]
264    pub description: ::core::option::Option<::prost::alloc::string::String>,
265    /// Rule meta_labels: Rule tags over the system.
266    #[prost(message, repeated, tag = "5")]
267    pub meta_labels: ::prost::alloc::vec::Vec<
268        super::super::meta_labels_protobuf::v1::MetaLabel,
269    >,
270    /// Rule filter: The rule filter definition over alert-events.
271    #[prost(message, optional, tag = "6")]
272    pub filter: ::core::option::Option<Filter>,
273    /// Rule schedule: The schedule time definition, how often the rule will be active.
274    #[prost(message, optional, tag = "7")]
275    pub schedule: ::core::option::Option<Schedule>,
276    /// Rule enabled: The rule activation mode.
277    #[prost(bool, tag = "8")]
278    pub enabled: bool,
279    /// Rule created_at: The date-time when the rule was created.
280    #[prost(string, optional, tag = "9")]
281    pub created_at: ::core::option::Option<::prost::alloc::string::String>,
282    /// Rule updated_at: The date-time when the rule was updated.
283    #[prost(string, optional, tag = "10")]
284    pub updated_at: ::core::option::Option<::prost::alloc::string::String>,
285}
286#[derive(serde::Serialize, serde::Deserialize)]
287#[serde(rename_all = "snake_case")]
288#[derive(Clone, PartialEq, ::prost::Message)]
289pub struct ActiveTimeframe {
290    /// Timeframe start time: The point in the time(date-time) when the rule will start to be active.
291    #[prost(string, tag = "1")]
292    pub start_time: ::prost::alloc::string::String,
293    /// Timeframe end time: The point in the time(date-time) when the rule will finish to be active.
294    #[prost(string, tag = "2")]
295    pub end_time: ::prost::alloc::string::String,
296    /// Timeframe timezone: The rule will be active according to a specific timezone.
297    #[prost(string, tag = "3")]
298    pub timezone: ::prost::alloc::string::String,
299}
300#[derive(serde::Serialize, serde::Deserialize)]
301#[serde(rename_all = "snake_case")]
302#[derive(Clone, PartialEq, ::prost::Message)]
303pub struct GetAlertSchedulerRuleRequest {
304    #[prost(string, tag = "1")]
305    pub alert_scheduler_rule_id: ::prost::alloc::string::String,
306}
307#[derive(serde::Serialize, serde::Deserialize)]
308#[serde(rename_all = "snake_case")]
309#[derive(Clone, PartialEq, ::prost::Message)]
310pub struct CreateAlertSchedulerRuleRequest {
311    #[prost(message, optional, tag = "1")]
312    pub alert_scheduler_rule: ::core::option::Option<AlertSchedulerRule>,
313}
314#[derive(serde::Serialize, serde::Deserialize)]
315#[serde(rename_all = "snake_case")]
316#[derive(Clone, PartialEq, ::prost::Message)]
317pub struct UpdateAlertSchedulerRuleRequest {
318    #[prost(message, optional, tag = "1")]
319    pub alert_scheduler_rule: ::core::option::Option<AlertSchedulerRule>,
320}
321#[derive(serde::Serialize, serde::Deserialize)]
322#[serde(rename_all = "snake_case")]
323#[derive(Clone, PartialEq, ::prost::Message)]
324pub struct DeleteAlertSchedulerRuleRequest {
325    #[prost(string, tag = "1")]
326    pub alert_scheduler_rule_id: ::prost::alloc::string::String,
327}
328#[derive(serde::Serialize, serde::Deserialize)]
329#[serde(rename_all = "snake_case")]
330#[derive(Clone, PartialEq, ::prost::Message)]
331pub struct AlertSchedulerRuleIds {
332    #[prost(string, repeated, tag = "1")]
333    pub alert_scheduler_rule_ids: ::prost::alloc::vec::Vec<
334        ::prost::alloc::string::String,
335    >,
336}
337#[derive(serde::Serialize, serde::Deserialize)]
338#[serde(rename_all = "snake_case")]
339#[derive(Clone, PartialEq, ::prost::Message)]
340pub struct AlertSchedulerRuleVersionIds {
341    #[prost(string, repeated, tag = "1")]
342    pub alert_scheduler_rule_version_ids: ::prost::alloc::vec::Vec<
343        ::prost::alloc::string::String,
344    >,
345}
346#[derive(serde::Serialize, serde::Deserialize)]
347#[serde(rename_all = "snake_case")]
348#[derive(Clone, PartialEq, ::prost::Message)]
349pub struct FilterByAlertSchedulerRuleIds {
350    #[prost(
351        oneof = "filter_by_alert_scheduler_rule_ids::AlertSchedulerRuleIds",
352        tags = "3, 4"
353    )]
354    pub alert_scheduler_rule_ids: ::core::option::Option<
355        filter_by_alert_scheduler_rule_ids::AlertSchedulerRuleIds,
356    >,
357}
358/// Nested message and enum types in `FilterByAlertSchedulerRuleIds`.
359pub mod filter_by_alert_scheduler_rule_ids {
360    #[derive(serde::Serialize, serde::Deserialize)]
361    #[serde(rename_all = "snake_case")]
362    #[derive(Clone, PartialEq, ::prost::Oneof)]
363    pub enum AlertSchedulerRuleIds {
364        #[prost(message, tag = "3")]
365        AlertSchedulerIds(super::AlertSchedulerRuleIds),
366        #[prost(message, tag = "4")]
367        AlertSchedulerVersionIds(super::AlertSchedulerRuleVersionIds),
368    }
369}
370#[derive(serde::Serialize, serde::Deserialize)]
371#[serde(rename_all = "snake_case")]
372#[derive(Clone, PartialEq, ::prost::Message)]
373pub struct GetBulkAlertSchedulerRuleRequest {
374    #[prost(message, optional, tag = "1")]
375    pub active_timeframe: ::core::option::Option<ActiveTimeframe>,
376    #[prost(bool, optional, tag = "2")]
377    pub enabled: ::core::option::Option<bool>,
378    #[prost(message, optional, tag = "3")]
379    pub alert_scheduler_rules_ids: ::core::option::Option<FilterByAlertSchedulerRuleIds>,
380    #[prost(string, optional, tag = "15")]
381    pub next_page_token: ::core::option::Option<::prost::alloc::string::String>,
382}
383#[derive(serde::Serialize, serde::Deserialize)]
384#[serde(rename_all = "snake_case")]
385#[derive(Clone, PartialEq, ::prost::Message)]
386pub struct CreateBulkAlertSchedulerRuleRequest {
387    #[prost(message, repeated, tag = "1")]
388    pub create_alert_scheduler_rule_requests: ::prost::alloc::vec::Vec<
389        CreateAlertSchedulerRuleRequest,
390    >,
391}
392#[derive(serde::Serialize, serde::Deserialize)]
393#[serde(rename_all = "snake_case")]
394#[derive(Clone, PartialEq, ::prost::Message)]
395pub struct UpdateBulkAlertSchedulerRuleRequest {
396    #[prost(message, repeated, tag = "1")]
397    pub update_alert_scheduler_rule_requests: ::prost::alloc::vec::Vec<
398        UpdateAlertSchedulerRuleRequest,
399    >,
400}
401#[derive(serde::Serialize, serde::Deserialize)]
402#[serde(rename_all = "snake_case")]
403#[derive(Clone, PartialEq, ::prost::Message)]
404pub struct DeleteBulkAlertSchedulerRuleRequest {
405    #[prost(message, repeated, tag = "1")]
406    pub delete_alert_scheduler_rule_requests: ::prost::alloc::vec::Vec<
407        DeleteAlertSchedulerRuleRequest,
408    >,
409}
410#[derive(serde::Serialize, serde::Deserialize)]
411#[serde(rename_all = "snake_case")]
412#[derive(Clone, PartialEq, ::prost::Message)]
413pub struct GetAlertSchedulerRuleResponse {
414    #[prost(message, optional, tag = "1")]
415    pub alert_scheduler_rule: ::core::option::Option<AlertSchedulerRule>,
416}
417#[derive(serde::Serialize, serde::Deserialize)]
418#[serde(rename_all = "snake_case")]
419#[derive(Clone, PartialEq, ::prost::Message)]
420pub struct CreateAlertSchedulerRuleResponse {
421    #[prost(message, optional, tag = "1")]
422    pub alert_scheduler_rule: ::core::option::Option<AlertSchedulerRule>,
423}
424#[derive(serde::Serialize, serde::Deserialize)]
425#[serde(rename_all = "snake_case")]
426#[derive(Clone, PartialEq, ::prost::Message)]
427pub struct UpdateAlertSchedulerRuleResponse {
428    #[prost(message, optional, tag = "1")]
429    pub alert_scheduler_rule: ::core::option::Option<AlertSchedulerRule>,
430}
431#[derive(serde::Serialize, serde::Deserialize)]
432#[serde(rename_all = "snake_case")]
433#[derive(Clone, Copy, PartialEq, ::prost::Message)]
434pub struct DeleteAlertSchedulerRuleResponse {}
435#[derive(serde::Serialize, serde::Deserialize)]
436#[serde(rename_all = "snake_case")]
437#[derive(Clone, PartialEq, ::prost::Message)]
438pub struct CreateBulkAlertSchedulerRuleResponse {
439    #[prost(message, repeated, tag = "1")]
440    pub create_suppression_responses: ::prost::alloc::vec::Vec<
441        CreateAlertSchedulerRuleResponse,
442    >,
443}
444#[derive(serde::Serialize, serde::Deserialize)]
445#[serde(rename_all = "snake_case")]
446#[derive(Clone, PartialEq, ::prost::Message)]
447pub struct UpdateBulkAlertSchedulerRuleResponse {
448    #[prost(message, repeated, tag = "1")]
449    pub update_suppression_responses: ::prost::alloc::vec::Vec<
450        UpdateAlertSchedulerRuleResponse,
451    >,
452}
453#[derive(serde::Serialize, serde::Deserialize)]
454#[serde(rename_all = "snake_case")]
455#[derive(Clone, PartialEq, ::prost::Message)]
456pub struct GetBulkAlertSchedulerRuleResponse {
457    #[prost(message, repeated, tag = "1")]
458    pub alert_scheduler_rules: ::prost::alloc::vec::Vec<
459        AlertSchedulerRuleWithActiveTimeframe,
460    >,
461    #[prost(string, tag = "2")]
462    pub next_page_token: ::prost::alloc::string::String,
463}
464#[derive(serde::Serialize, serde::Deserialize)]
465#[serde(rename_all = "snake_case")]
466#[derive(Clone, PartialEq, ::prost::Message)]
467pub struct AlertSchedulerRuleWithActiveTimeframe {
468    #[prost(message, optional, tag = "1")]
469    pub alert_scheduler_rule: ::core::option::Option<AlertSchedulerRule>,
470    #[prost(message, repeated, tag = "2")]
471    pub next_active_timeframes: ::prost::alloc::vec::Vec<ActiveTimeframe>,
472}
473/// Generated client implementations.
474pub mod alert_scheduler_rule_service_client {
475    #![allow(
476        unused_variables,
477        dead_code,
478        missing_docs,
479        clippy::wildcard_imports,
480        clippy::let_unit_value,
481    )]
482    use tonic::codegen::*;
483    use tonic::codegen::http::Uri;
484    #[derive(Debug, Clone)]
485    pub struct AlertSchedulerRuleServiceClient<T> {
486        inner: tonic::client::Grpc<T>,
487    }
488    impl AlertSchedulerRuleServiceClient<tonic::transport::Channel> {
489        /// Attempt to create a new client by connecting to a given endpoint.
490        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
491        where
492            D: TryInto<tonic::transport::Endpoint>,
493            D::Error: Into<StdError>,
494        {
495            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
496            Ok(Self::new(conn))
497        }
498    }
499    impl<T> AlertSchedulerRuleServiceClient<T>
500    where
501        T: tonic::client::GrpcService<tonic::body::BoxBody>,
502        T::Error: Into<StdError>,
503        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
504        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
505    {
506        pub fn new(inner: T) -> Self {
507            let inner = tonic::client::Grpc::new(inner);
508            Self { inner }
509        }
510        pub fn with_origin(inner: T, origin: Uri) -> Self {
511            let inner = tonic::client::Grpc::with_origin(inner, origin);
512            Self { inner }
513        }
514        pub fn with_interceptor<F>(
515            inner: T,
516            interceptor: F,
517        ) -> AlertSchedulerRuleServiceClient<InterceptedService<T, F>>
518        where
519            F: tonic::service::Interceptor,
520            T::ResponseBody: Default,
521            T: tonic::codegen::Service<
522                http::Request<tonic::body::BoxBody>,
523                Response = http::Response<
524                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
525                >,
526            >,
527            <T as tonic::codegen::Service<
528                http::Request<tonic::body::BoxBody>,
529            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
530        {
531            AlertSchedulerRuleServiceClient::new(
532                InterceptedService::new(inner, interceptor),
533            )
534        }
535        /// Compress requests with the given encoding.
536        ///
537        /// This requires the server to support it otherwise it might respond with an
538        /// error.
539        #[must_use]
540        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
541            self.inner = self.inner.send_compressed(encoding);
542            self
543        }
544        /// Enable decompressing responses.
545        #[must_use]
546        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
547            self.inner = self.inner.accept_compressed(encoding);
548            self
549        }
550        /// Limits the maximum size of a decoded message.
551        ///
552        /// Default: `4MB`
553        #[must_use]
554        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
555            self.inner = self.inner.max_decoding_message_size(limit);
556            self
557        }
558        /// Limits the maximum size of an encoded message.
559        ///
560        /// Default: `usize::MAX`
561        #[must_use]
562        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
563            self.inner = self.inner.max_encoding_message_size(limit);
564            self
565        }
566        pub async fn get_alert_scheduler_rule(
567            &mut self,
568            request: impl tonic::IntoRequest<super::GetAlertSchedulerRuleRequest>,
569        ) -> std::result::Result<
570            tonic::Response<super::GetAlertSchedulerRuleResponse>,
571            tonic::Status,
572        > {
573            self.inner
574                .ready()
575                .await
576                .map_err(|e| {
577                    tonic::Status::unknown(
578                        format!("Service was not ready: {}", e.into()),
579                    )
580                })?;
581            let codec = tonic::codec::ProstCodec::default();
582            let path = http::uri::PathAndQuery::from_static(
583                "/com.coralogixapis.alerting.alert_scheduler_rule_protobuf.v1.AlertSchedulerRuleService/GetAlertSchedulerRule",
584            );
585            let mut req = request.into_request();
586            req.extensions_mut()
587                .insert(
588                    GrpcMethod::new(
589                        "com.coralogixapis.alerting.alert_scheduler_rule_protobuf.v1.AlertSchedulerRuleService",
590                        "GetAlertSchedulerRule",
591                    ),
592                );
593            self.inner.unary(req, path, codec).await
594        }
595        pub async fn create_alert_scheduler_rule(
596            &mut self,
597            request: impl tonic::IntoRequest<super::CreateAlertSchedulerRuleRequest>,
598        ) -> std::result::Result<
599            tonic::Response<super::CreateAlertSchedulerRuleResponse>,
600            tonic::Status,
601        > {
602            self.inner
603                .ready()
604                .await
605                .map_err(|e| {
606                    tonic::Status::unknown(
607                        format!("Service was not ready: {}", e.into()),
608                    )
609                })?;
610            let codec = tonic::codec::ProstCodec::default();
611            let path = http::uri::PathAndQuery::from_static(
612                "/com.coralogixapis.alerting.alert_scheduler_rule_protobuf.v1.AlertSchedulerRuleService/CreateAlertSchedulerRule",
613            );
614            let mut req = request.into_request();
615            req.extensions_mut()
616                .insert(
617                    GrpcMethod::new(
618                        "com.coralogixapis.alerting.alert_scheduler_rule_protobuf.v1.AlertSchedulerRuleService",
619                        "CreateAlertSchedulerRule",
620                    ),
621                );
622            self.inner.unary(req, path, codec).await
623        }
624        pub async fn update_alert_scheduler_rule(
625            &mut self,
626            request: impl tonic::IntoRequest<super::UpdateAlertSchedulerRuleRequest>,
627        ) -> std::result::Result<
628            tonic::Response<super::UpdateAlertSchedulerRuleResponse>,
629            tonic::Status,
630        > {
631            self.inner
632                .ready()
633                .await
634                .map_err(|e| {
635                    tonic::Status::unknown(
636                        format!("Service was not ready: {}", e.into()),
637                    )
638                })?;
639            let codec = tonic::codec::ProstCodec::default();
640            let path = http::uri::PathAndQuery::from_static(
641                "/com.coralogixapis.alerting.alert_scheduler_rule_protobuf.v1.AlertSchedulerRuleService/UpdateAlertSchedulerRule",
642            );
643            let mut req = request.into_request();
644            req.extensions_mut()
645                .insert(
646                    GrpcMethod::new(
647                        "com.coralogixapis.alerting.alert_scheduler_rule_protobuf.v1.AlertSchedulerRuleService",
648                        "UpdateAlertSchedulerRule",
649                    ),
650                );
651            self.inner.unary(req, path, codec).await
652        }
653        pub async fn delete_alert_scheduler_rule(
654            &mut self,
655            request: impl tonic::IntoRequest<super::DeleteAlertSchedulerRuleRequest>,
656        ) -> std::result::Result<
657            tonic::Response<super::DeleteAlertSchedulerRuleResponse>,
658            tonic::Status,
659        > {
660            self.inner
661                .ready()
662                .await
663                .map_err(|e| {
664                    tonic::Status::unknown(
665                        format!("Service was not ready: {}", e.into()),
666                    )
667                })?;
668            let codec = tonic::codec::ProstCodec::default();
669            let path = http::uri::PathAndQuery::from_static(
670                "/com.coralogixapis.alerting.alert_scheduler_rule_protobuf.v1.AlertSchedulerRuleService/DeleteAlertSchedulerRule",
671            );
672            let mut req = request.into_request();
673            req.extensions_mut()
674                .insert(
675                    GrpcMethod::new(
676                        "com.coralogixapis.alerting.alert_scheduler_rule_protobuf.v1.AlertSchedulerRuleService",
677                        "DeleteAlertSchedulerRule",
678                    ),
679                );
680            self.inner.unary(req, path, codec).await
681        }
682        pub async fn get_bulk_alert_scheduler_rule(
683            &mut self,
684            request: impl tonic::IntoRequest<super::GetBulkAlertSchedulerRuleRequest>,
685        ) -> std::result::Result<
686            tonic::Response<super::GetBulkAlertSchedulerRuleResponse>,
687            tonic::Status,
688        > {
689            self.inner
690                .ready()
691                .await
692                .map_err(|e| {
693                    tonic::Status::unknown(
694                        format!("Service was not ready: {}", e.into()),
695                    )
696                })?;
697            let codec = tonic::codec::ProstCodec::default();
698            let path = http::uri::PathAndQuery::from_static(
699                "/com.coralogixapis.alerting.alert_scheduler_rule_protobuf.v1.AlertSchedulerRuleService/GetBulkAlertSchedulerRule",
700            );
701            let mut req = request.into_request();
702            req.extensions_mut()
703                .insert(
704                    GrpcMethod::new(
705                        "com.coralogixapis.alerting.alert_scheduler_rule_protobuf.v1.AlertSchedulerRuleService",
706                        "GetBulkAlertSchedulerRule",
707                    ),
708                );
709            self.inner.unary(req, path, codec).await
710        }
711        pub async fn create_bulk_alert_scheduler_rule(
712            &mut self,
713            request: impl tonic::IntoRequest<super::CreateBulkAlertSchedulerRuleRequest>,
714        ) -> std::result::Result<
715            tonic::Response<super::CreateBulkAlertSchedulerRuleResponse>,
716            tonic::Status,
717        > {
718            self.inner
719                .ready()
720                .await
721                .map_err(|e| {
722                    tonic::Status::unknown(
723                        format!("Service was not ready: {}", e.into()),
724                    )
725                })?;
726            let codec = tonic::codec::ProstCodec::default();
727            let path = http::uri::PathAndQuery::from_static(
728                "/com.coralogixapis.alerting.alert_scheduler_rule_protobuf.v1.AlertSchedulerRuleService/CreateBulkAlertSchedulerRule",
729            );
730            let mut req = request.into_request();
731            req.extensions_mut()
732                .insert(
733                    GrpcMethod::new(
734                        "com.coralogixapis.alerting.alert_scheduler_rule_protobuf.v1.AlertSchedulerRuleService",
735                        "CreateBulkAlertSchedulerRule",
736                    ),
737                );
738            self.inner.unary(req, path, codec).await
739        }
740        pub async fn update_bulk_alert_scheduler_rule(
741            &mut self,
742            request: impl tonic::IntoRequest<super::UpdateBulkAlertSchedulerRuleRequest>,
743        ) -> std::result::Result<
744            tonic::Response<super::UpdateBulkAlertSchedulerRuleResponse>,
745            tonic::Status,
746        > {
747            self.inner
748                .ready()
749                .await
750                .map_err(|e| {
751                    tonic::Status::unknown(
752                        format!("Service was not ready: {}", e.into()),
753                    )
754                })?;
755            let codec = tonic::codec::ProstCodec::default();
756            let path = http::uri::PathAndQuery::from_static(
757                "/com.coralogixapis.alerting.alert_scheduler_rule_protobuf.v1.AlertSchedulerRuleService/UpdateBulkAlertSchedulerRule",
758            );
759            let mut req = request.into_request();
760            req.extensions_mut()
761                .insert(
762                    GrpcMethod::new(
763                        "com.coralogixapis.alerting.alert_scheduler_rule_protobuf.v1.AlertSchedulerRuleService",
764                        "UpdateBulkAlertSchedulerRule",
765                    ),
766                );
767            self.inner.unary(req, path, codec).await
768        }
769    }
770}