1#[derive(serde::Serialize, serde::Deserialize)]
3#[serde(rename_all = "snake_case")]
4#[derive(Clone, PartialEq, ::prost::Message)]
5pub struct Filter {
6 #[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}
12pub 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 #[prost(message, tag = "2")]
20 AlertMetaLabels(super::MetaLabels),
21 #[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 #[prost(string, tag = "1")]
48 pub start_time: ::prost::alloc::string::String,
49 #[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}
55pub 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 #[prost(string, tag = "2")]
63 EndTime(::prost::alloc::string::String),
64 #[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 #[prost(int32, tag = "1")]
75 pub for_over: i32,
76 #[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 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 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 #[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}
124pub 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 #[prost(message, tag = "2")]
132 OneTime(super::OneTime),
133 #[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}
152pub 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 #[prost(int32, tag = "1")]
164 pub repeat_every: i32,
165 #[prost(message, optional, tag = "5")]
167 pub timeframe: ::core::option::Option<super::Timeframe>,
168 #[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 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 #[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 #[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 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 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 #[prost(string, optional, tag = "1")]
255 pub unique_identifier: ::core::option::Option<::prost::alloc::string::String>,
256 #[prost(string, optional, tag = "2")]
258 pub id: ::core::option::Option<::prost::alloc::string::String>,
259 #[prost(string, tag = "3")]
261 pub name: ::prost::alloc::string::String,
262 #[prost(string, optional, tag = "4")]
264 pub description: ::core::option::Option<::prost::alloc::string::String>,
265 #[prost(message, repeated, tag = "5")]
267 pub meta_labels: ::prost::alloc::vec::Vec<
268 super::super::meta_labels_protobuf::v1::MetaLabel,
269 >,
270 #[prost(message, optional, tag = "6")]
272 pub filter: ::core::option::Option<Filter>,
273 #[prost(message, optional, tag = "7")]
275 pub schedule: ::core::option::Option<Schedule>,
276 #[prost(bool, tag = "8")]
278 pub enabled: bool,
279 #[prost(string, optional, tag = "9")]
281 pub created_at: ::core::option::Option<::prost::alloc::string::String>,
282 #[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 #[prost(string, tag = "1")]
292 pub start_time: ::prost::alloc::string::String,
293 #[prost(string, tag = "2")]
295 pub end_time: ::prost::alloc::string::String,
296 #[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}
358pub 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}
473pub 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 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 #[must_use]
540 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
541 self.inner = self.inner.send_compressed(encoding);
542 self
543 }
544 #[must_use]
546 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
547 self.inner = self.inner.accept_compressed(encoding);
548 self
549 }
550 #[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 #[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}