cx_api/generated/
com.coralogix.extensions.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 ExtensionItemBinary {
6    #[prost(enumeration = "extension_item_binary::BinaryType", tag = "1")]
7    pub r#type: i32,
8    #[prost(message, optional, tag = "2")]
9    pub data: ::core::option::Option<::prost::alloc::string::String>,
10    #[prost(message, optional, tag = "3")]
11    pub file_name: ::core::option::Option<::prost::alloc::string::String>,
12}
13/// Nested message and enum types in `ExtensionItemBinary`.
14pub mod extension_item_binary {
15    #[derive(serde::Serialize, serde::Deserialize)]
16    #[serde(rename_all = "snake_case")]
17    #[derive(
18        Clone,
19        Copy,
20        Debug,
21        PartialEq,
22        Eq,
23        Hash,
24        PartialOrd,
25        Ord,
26        ::prost::Enumeration
27    )]
28    #[repr(i32)]
29    pub enum BinaryType {
30        PreviewImage = 0,
31        KibanaDashboardDefinition = 1,
32        GrafanaDashboardDefinition = 2,
33        EnrichmentCsv = 3,
34        CxCustomDashboardDefinition = 4,
35    }
36    impl BinaryType {
37        /// String value of the enum field names used in the ProtoBuf definition.
38        ///
39        /// The values are not transformed in any way and thus are considered stable
40        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
41        pub fn as_str_name(&self) -> &'static str {
42            match self {
43                Self::PreviewImage => "PREVIEW_IMAGE",
44                Self::KibanaDashboardDefinition => "KIBANA_DASHBOARD_DEFINITION",
45                Self::GrafanaDashboardDefinition => "GRAFANA_DASHBOARD_DEFINITION",
46                Self::EnrichmentCsv => "ENRICHMENT_CSV",
47                Self::CxCustomDashboardDefinition => "CX_CUSTOM_DASHBOARD_DEFINITION",
48            }
49        }
50        /// Creates an enum from field names used in the ProtoBuf definition.
51        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
52            match value {
53                "PREVIEW_IMAGE" => Some(Self::PreviewImage),
54                "KIBANA_DASHBOARD_DEFINITION" => Some(Self::KibanaDashboardDefinition),
55                "GRAFANA_DASHBOARD_DEFINITION" => Some(Self::GrafanaDashboardDefinition),
56                "ENRICHMENT_CSV" => Some(Self::EnrichmentCsv),
57                "CX_CUSTOM_DASHBOARD_DEFINITION" => {
58                    Some(Self::CxCustomDashboardDefinition)
59                }
60                _ => None,
61            }
62        }
63    }
64}
65#[derive(serde::Serialize, serde::Deserialize)]
66#[serde(rename_all = "snake_case")]
67#[derive(Clone, PartialEq, ::prost::Message)]
68pub struct ExtensionItem {
69    #[prost(message, optional, tag = "1")]
70    pub id: ::core::option::Option<::prost::alloc::string::String>,
71    #[prost(message, optional, tag = "2")]
72    pub name: ::core::option::Option<::prost::alloc::string::String>,
73    #[prost(message, optional, tag = "3")]
74    pub description: ::core::option::Option<::prost::alloc::string::String>,
75    #[prost(enumeration = "TargetDomain", tag = "4")]
76    pub target_domain: i32,
77    #[prost(message, optional, tag = "5")]
78    pub data: ::core::option::Option<::prost_wkt_types::Struct>,
79    #[prost(message, repeated, tag = "6")]
80    pub binaries: ::prost::alloc::vec::Vec<ExtensionItemBinary>,
81    #[prost(message, optional, tag = "7")]
82    pub is_mandatory: ::core::option::Option<bool>,
83    #[prost(enumeration = "extension_item::PermissionResource", tag = "9")]
84    pub permission_resource: i32,
85    #[prost(message, optional, tag = "10")]
86    pub extended_internal_id: ::core::option::Option<::prost::alloc::string::String>,
87    #[prost(message, optional, tag = "11")]
88    pub unique_id: ::core::option::Option<::prost::alloc::string::String>,
89    #[prost(message, optional, tag = "12")]
90    pub stable_id: ::core::option::Option<::prost::alloc::string::String>,
91}
92/// Nested message and enum types in `ExtensionItem`.
93pub mod extension_item {
94    #[derive(serde::Serialize, serde::Deserialize)]
95    #[serde(rename_all = "snake_case")]
96    #[derive(
97        Clone,
98        Copy,
99        Debug,
100        PartialEq,
101        Eq,
102        Hash,
103        PartialOrd,
104        Ord,
105        ::prost::Enumeration
106    )]
107    #[repr(i32)]
108    pub enum PermissionResource {
109        Unknown = 0,
110        Action = 1,
111        Alert = 2,
112        CustomEnrichment = 3,
113        GeoEnrichment = 4,
114        SecurityEnrichment = 5,
115        ResourceCloudMetadataEnrichment = 6,
116        GrafanaDashboard = 7,
117        KibanaDashboard = 8,
118        ParsingRule = 9,
119        SavedView = 10,
120        CxCustomDashboard = 11,
121        MetricsRuleGroup = 12,
122        SpanEventsToMetrics = 13,
123        LogsEventsToMetrics = 14,
124    }
125    impl PermissionResource {
126        /// String value of the enum field names used in the ProtoBuf definition.
127        ///
128        /// The values are not transformed in any way and thus are considered stable
129        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
130        pub fn as_str_name(&self) -> &'static str {
131            match self {
132                Self::Unknown => "UNKNOWN",
133                Self::Action => "ACTION",
134                Self::Alert => "ALERT",
135                Self::CustomEnrichment => "CUSTOM_ENRICHMENT",
136                Self::GeoEnrichment => "GEO_ENRICHMENT",
137                Self::SecurityEnrichment => "SECURITY_ENRICHMENT",
138                Self::ResourceCloudMetadataEnrichment => {
139                    "RESOURCE_CLOUD_METADATA_ENRICHMENT"
140                }
141                Self::GrafanaDashboard => "GRAFANA_DASHBOARD",
142                Self::KibanaDashboard => "KIBANA_DASHBOARD",
143                Self::ParsingRule => "PARSING_RULE",
144                Self::SavedView => "SAVED_VIEW",
145                Self::CxCustomDashboard => "CX_CUSTOM_DASHBOARD",
146                Self::MetricsRuleGroup => "METRICS_RULE_GROUP",
147                Self::SpanEventsToMetrics => "SPAN_EVENTS_TO_METRICS",
148                Self::LogsEventsToMetrics => "LOGS_EVENTS_TO_METRICS",
149            }
150        }
151        /// Creates an enum from field names used in the ProtoBuf definition.
152        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
153            match value {
154                "UNKNOWN" => Some(Self::Unknown),
155                "ACTION" => Some(Self::Action),
156                "ALERT" => Some(Self::Alert),
157                "CUSTOM_ENRICHMENT" => Some(Self::CustomEnrichment),
158                "GEO_ENRICHMENT" => Some(Self::GeoEnrichment),
159                "SECURITY_ENRICHMENT" => Some(Self::SecurityEnrichment),
160                "RESOURCE_CLOUD_METADATA_ENRICHMENT" => {
161                    Some(Self::ResourceCloudMetadataEnrichment)
162                }
163                "GRAFANA_DASHBOARD" => Some(Self::GrafanaDashboard),
164                "KIBANA_DASHBOARD" => Some(Self::KibanaDashboard),
165                "PARSING_RULE" => Some(Self::ParsingRule),
166                "SAVED_VIEW" => Some(Self::SavedView),
167                "CX_CUSTOM_DASHBOARD" => Some(Self::CxCustomDashboard),
168                "METRICS_RULE_GROUP" => Some(Self::MetricsRuleGroup),
169                "SPAN_EVENTS_TO_METRICS" => Some(Self::SpanEventsToMetrics),
170                "LOGS_EVENTS_TO_METRICS" => Some(Self::LogsEventsToMetrics),
171                _ => None,
172            }
173        }
174    }
175}
176#[derive(serde::Serialize, serde::Deserialize)]
177#[serde(rename_all = "snake_case")]
178#[derive(Clone, Copy, PartialEq, ::prost::Message)]
179pub struct ItemCounts {
180    #[prost(message, optional, tag = "1")]
181    pub actions: ::core::option::Option<u32>,
182    #[prost(message, optional, tag = "2")]
183    pub alerts: ::core::option::Option<u32>,
184    #[prost(message, optional, tag = "3")]
185    pub custom_dashboards: ::core::option::Option<u32>,
186    #[prost(message, optional, tag = "4")]
187    pub enrichments: ::core::option::Option<u32>,
188    #[prost(message, optional, tag = "5")]
189    pub events_to_metrics: ::core::option::Option<u32>,
190    #[prost(message, optional, tag = "6")]
191    pub grafana_dashboards: ::core::option::Option<u32>,
192    #[prost(message, optional, tag = "7")]
193    pub kibana_dashboards: ::core::option::Option<u32>,
194    #[prost(message, optional, tag = "8")]
195    pub metrics_rule_group: ::core::option::Option<u32>,
196    #[prost(message, optional, tag = "9")]
197    pub parsing_rules: ::core::option::Option<u32>,
198    #[prost(message, optional, tag = "10")]
199    pub saved_views: ::core::option::Option<u32>,
200}
201#[derive(serde::Serialize, serde::Deserialize)]
202#[serde(rename_all = "snake_case")]
203#[derive(Clone, PartialEq, ::prost::Message)]
204pub struct IntegrationDetail {
205    #[prost(message, optional, tag = "1")]
206    pub name: ::core::option::Option<::prost::alloc::string::String>,
207    #[prost(message, optional, tag = "2")]
208    pub link: ::core::option::Option<::prost::alloc::string::String>,
209}
210#[derive(serde::Serialize, serde::Deserialize)]
211#[serde(rename_all = "snake_case")]
212#[derive(Clone, PartialEq, ::prost::Message)]
213pub struct ExtensionBinary {
214    #[prost(enumeration = "extension_binary::BinaryType", tag = "1")]
215    pub r#type: i32,
216    #[prost(message, optional, tag = "2")]
217    pub data: ::core::option::Option<::prost::alloc::string::String>,
218}
219/// Nested message and enum types in `ExtensionBinary`.
220pub mod extension_binary {
221    #[derive(serde::Serialize, serde::Deserialize)]
222    #[serde(rename_all = "snake_case")]
223    #[derive(
224        Clone,
225        Copy,
226        Debug,
227        PartialEq,
228        Eq,
229        Hash,
230        PartialOrd,
231        Ord,
232        ::prost::Enumeration
233    )]
234    #[repr(i32)]
235    pub enum BinaryType {
236        KibanaIndexPattern = 0,
237    }
238    impl BinaryType {
239        /// String value of the enum field names used in the ProtoBuf definition.
240        ///
241        /// The values are not transformed in any way and thus are considered stable
242        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
243        pub fn as_str_name(&self) -> &'static str {
244            match self {
245                Self::KibanaIndexPattern => "KIBANA_INDEX_PATTERN",
246            }
247        }
248        /// Creates an enum from field names used in the ProtoBuf definition.
249        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
250            match value {
251                "KIBANA_INDEX_PATTERN" => Some(Self::KibanaIndexPattern),
252                _ => None,
253            }
254        }
255    }
256}
257#[derive(serde::Serialize, serde::Deserialize)]
258#[serde(rename_all = "snake_case")]
259#[derive(Clone, PartialEq, ::prost::Message)]
260pub struct ChangelogEntry {
261    #[prost(message, optional, tag = "1")]
262    pub version: ::core::option::Option<::prost::alloc::string::String>,
263    #[prost(message, optional, tag = "2")]
264    pub description_md: ::core::option::Option<::prost::alloc::string::String>,
265}
266#[derive(serde::Serialize, serde::Deserialize)]
267#[serde(rename_all = "snake_case")]
268#[derive(Clone, PartialEq, ::prost::Message)]
269pub struct Deprecation {
270    #[prost(message, optional, tag = "1")]
271    pub reason: ::core::option::Option<::prost::alloc::string::String>,
272    #[prost(message, repeated, tag = "2")]
273    pub replacement_extensions: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
274}
275#[derive(serde::Serialize, serde::Deserialize)]
276#[serde(rename_all = "snake_case")]
277#[derive(Clone, PartialEq, ::prost::Message)]
278pub struct ExtensionRevision {
279    #[prost(message, optional, tag = "1")]
280    pub version: ::core::option::Option<::prost::alloc::string::String>,
281    #[prost(message, optional, tag = "2")]
282    pub description: ::core::option::Option<::prost::alloc::string::String>,
283    #[prost(message, optional, tag = "3")]
284    pub excerpt: ::core::option::Option<::prost::alloc::string::String>,
285    #[prost(message, repeated, tag = "4")]
286    pub labels: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
287    #[prost(message, repeated, tag = "5")]
288    pub integration_details: ::prost::alloc::vec::Vec<IntegrationDetail>,
289    #[prost(message, repeated, tag = "6")]
290    pub items: ::prost::alloc::vec::Vec<ExtensionItem>,
291    #[prost(message, repeated, tag = "7")]
292    pub binaries: ::prost::alloc::vec::Vec<ExtensionBinary>,
293    #[prost(message, repeated, tag = "8")]
294    pub permission_denied_items: ::prost::alloc::vec::Vec<ExtensionItem>,
295    #[prost(message, optional, tag = "9")]
296    pub is_testing: ::core::option::Option<bool>,
297}
298#[derive(serde::Serialize, serde::Deserialize)]
299#[serde(rename_all = "snake_case")]
300#[derive(Clone, PartialEq, ::prost::Message)]
301pub struct Extension {
302    #[prost(message, optional, tag = "1")]
303    pub id: ::core::option::Option<::prost::alloc::string::String>,
304    #[prost(message, optional, tag = "2")]
305    pub name: ::core::option::Option<::prost::alloc::string::String>,
306    #[prost(message, optional, tag = "3")]
307    pub image: ::core::option::Option<::prost::alloc::string::String>,
308    #[prost(message, optional, tag = "4")]
309    pub dark_mode_image: ::core::option::Option<::prost::alloc::string::String>,
310    #[prost(message, repeated, tag = "5")]
311    pub revisions: ::prost::alloc::vec::Vec<ExtensionRevision>,
312    #[prost(message, optional, tag = "6")]
313    pub is_hidden: ::core::option::Option<bool>,
314    #[prost(string, repeated, tag = "7")]
315    pub integrations: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
316    #[prost(message, repeated, tag = "8")]
317    pub keywords: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
318    #[prost(message, repeated, tag = "9")]
319    pub permission_denied_revisions: ::prost::alloc::vec::Vec<ExtensionRevision>,
320    #[prost(message, repeated, tag = "10")]
321    pub changelog: ::prost::alloc::vec::Vec<ChangelogEntry>,
322    #[prost(message, optional, tag = "11")]
323    pub deprecation: ::core::option::Option<Deprecation>,
324}
325/// Extension details for ingestion
326#[derive(serde::Serialize, serde::Deserialize)]
327#[serde(rename_all = "snake_case")]
328#[derive(Clone, PartialEq, ::prost::Message)]
329pub struct ExtensionData {
330    #[prost(message, optional, tag = "1")]
331    pub id: ::core::option::Option<::prost::alloc::string::String>,
332    #[prost(message, optional, tag = "2")]
333    pub name: ::core::option::Option<::prost::alloc::string::String>,
334    #[prost(message, optional, tag = "3")]
335    pub description: ::core::option::Option<::prost::alloc::string::String>,
336    #[prost(message, optional, tag = "4")]
337    pub excerpt: ::core::option::Option<::prost::alloc::string::String>,
338    #[prost(message, optional, tag = "5")]
339    pub image: ::core::option::Option<::prost::alloc::string::String>,
340    #[prost(message, optional, tag = "6")]
341    pub dark_mode_image: ::core::option::Option<::prost::alloc::string::String>,
342    #[prost(message, repeated, tag = "7")]
343    pub labels: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
344    #[prost(message, optional, tag = "8")]
345    pub version: ::core::option::Option<::prost::alloc::string::String>,
346    #[prost(message, repeated, tag = "9")]
347    pub items: ::prost::alloc::vec::Vec<ExtensionItemData>,
348    #[prost(message, repeated, tag = "10")]
349    pub integration_details: ::prost::alloc::vec::Vec<IntegrationDetail>,
350    #[prost(message, optional, tag = "11")]
351    pub is_hidden: ::core::option::Option<bool>,
352    #[prost(message, repeated, tag = "12")]
353    pub binaries: ::prost::alloc::vec::Vec<ExtensionBinary>,
354    #[prost(string, repeated, tag = "13")]
355    pub integrations: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
356    #[prost(message, repeated, tag = "14")]
357    pub keywords: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
358    #[prost(message, repeated, tag = "15")]
359    pub changelog: ::prost::alloc::vec::Vec<ChangelogEntry>,
360    #[prost(message, optional, tag = "16")]
361    pub deprecation: ::core::option::Option<Deprecation>,
362}
363#[derive(serde::Serialize, serde::Deserialize)]
364#[serde(rename_all = "snake_case")]
365#[derive(Clone, PartialEq, ::prost::Message)]
366pub struct ExtensionItemData {
367    #[prost(message, optional, tag = "1")]
368    pub name: ::core::option::Option<::prost::alloc::string::String>,
369    #[prost(message, optional, tag = "2")]
370    pub description: ::core::option::Option<::prost::alloc::string::String>,
371    #[prost(enumeration = "TargetDomain", tag = "3")]
372    pub target_domain: i32,
373    #[prost(message, optional, tag = "4")]
374    pub data: ::core::option::Option<::prost_wkt_types::Struct>,
375    #[prost(message, repeated, tag = "5")]
376    pub binaries: ::prost::alloc::vec::Vec<ExtensionItemBinary>,
377    #[prost(message, optional, tag = "6")]
378    pub is_mandatory: ::core::option::Option<bool>,
379    #[prost(message, optional, tag = "7")]
380    pub internal_id: ::core::option::Option<i32>,
381    #[prost(message, optional, tag = "8")]
382    pub unique_id: ::core::option::Option<::prost::alloc::string::String>,
383    #[prost(enumeration = "extension_item::PermissionResource", tag = "9")]
384    pub permission_resource: i32,
385    #[prost(message, optional, tag = "10")]
386    pub stable_id: ::core::option::Option<::prost::alloc::string::String>,
387}
388#[derive(serde::Serialize, serde::Deserialize)]
389#[serde(rename_all = "snake_case")]
390#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
391#[repr(i32)]
392pub enum TargetDomain {
393    Action = 0,
394    Alert = 1,
395    Enrichment = 2,
396    GrafanaDashboard = 3,
397    KibanaDashboard = 4,
398    ParsingRule = 6,
399    SavedView = 7,
400    CxCustomDashboard = 8,
401    MetricsRuleGroup = 9,
402    EventsToMetrics = 10,
403    AlertV3 = 11,
404}
405impl TargetDomain {
406    /// String value of the enum field names used in the ProtoBuf definition.
407    ///
408    /// The values are not transformed in any way and thus are considered stable
409    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
410    pub fn as_str_name(&self) -> &'static str {
411        match self {
412            Self::Action => "ACTION",
413            Self::Alert => "ALERT",
414            Self::Enrichment => "ENRICHMENT",
415            Self::GrafanaDashboard => "GRAFANA_DASHBOARD",
416            Self::KibanaDashboard => "KIBANA_DASHBOARD",
417            Self::ParsingRule => "PARSING_RULE",
418            Self::SavedView => "SAVED_VIEW",
419            Self::CxCustomDashboard => "CX_CUSTOM_DASHBOARD",
420            Self::MetricsRuleGroup => "METRICS_RULE_GROUP",
421            Self::EventsToMetrics => "EVENTS_TO_METRICS",
422            Self::AlertV3 => "ALERT_V3",
423        }
424    }
425    /// Creates an enum from field names used in the ProtoBuf definition.
426    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
427        match value {
428            "ACTION" => Some(Self::Action),
429            "ALERT" => Some(Self::Alert),
430            "ENRICHMENT" => Some(Self::Enrichment),
431            "GRAFANA_DASHBOARD" => Some(Self::GrafanaDashboard),
432            "KIBANA_DASHBOARD" => Some(Self::KibanaDashboard),
433            "PARSING_RULE" => Some(Self::ParsingRule),
434            "SAVED_VIEW" => Some(Self::SavedView),
435            "CX_CUSTOM_DASHBOARD" => Some(Self::CxCustomDashboard),
436            "METRICS_RULE_GROUP" => Some(Self::MetricsRuleGroup),
437            "EVENTS_TO_METRICS" => Some(Self::EventsToMetrics),
438            "ALERT_V3" => Some(Self::AlertV3),
439            _ => None,
440        }
441    }
442}
443#[derive(serde::Serialize, serde::Deserialize)]
444#[serde(rename_all = "snake_case")]
445#[derive(Clone, PartialEq, ::prost::Message)]
446pub struct GetAllExtensionsRequest {
447    #[prost(message, optional, tag = "1")]
448    pub include_hidden_extensions: ::core::option::Option<bool>,
449    #[prost(message, optional, tag = "2")]
450    pub filter: ::core::option::Option<get_all_extensions_request::Filter>,
451}
452/// Nested message and enum types in `GetAllExtensionsRequest`.
453pub mod get_all_extensions_request {
454    #[derive(serde::Serialize, serde::Deserialize)]
455    #[serde(rename_all = "snake_case")]
456    #[derive(Clone, PartialEq, ::prost::Message)]
457    pub struct Filter {
458        #[prost(string, repeated, tag = "1")]
459        pub integrations: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
460    }
461}
462#[derive(serde::Serialize, serde::Deserialize)]
463#[serde(rename_all = "snake_case")]
464#[derive(Clone, PartialEq, ::prost::Message)]
465pub struct GetAllExtensionsResponse {
466    #[prost(message, repeated, tag = "1")]
467    pub extensions: ::prost::alloc::vec::Vec<get_all_extensions_response::Extension>,
468}
469/// Nested message and enum types in `GetAllExtensionsResponse`.
470pub mod get_all_extensions_response {
471    #[derive(serde::Serialize, serde::Deserialize)]
472    #[serde(rename_all = "snake_case")]
473    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
474    pub struct RevisionSummary {
475        #[prost(message, optional, tag = "1")]
476        pub item_counts: ::core::option::Option<super::ItemCounts>,
477        #[prost(message, optional, tag = "2")]
478        pub is_new: ::core::option::Option<bool>,
479    }
480    #[derive(serde::Serialize, serde::Deserialize)]
481    #[serde(rename_all = "snake_case")]
482    #[derive(Clone, PartialEq, ::prost::Message)]
483    pub struct Revision {
484        #[prost(message, optional, tag = "1")]
485        pub version: ::core::option::Option<::prost::alloc::string::String>,
486        #[prost(message, optional, tag = "2")]
487        pub description: ::core::option::Option<::prost::alloc::string::String>,
488        #[prost(message, optional, tag = "3")]
489        pub excerpt: ::core::option::Option<::prost::alloc::string::String>,
490        #[prost(message, repeated, tag = "4")]
491        pub labels: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
492        #[prost(message, repeated, tag = "5")]
493        pub integration_details: ::prost::alloc::vec::Vec<super::IntegrationDetail>,
494        #[prost(message, optional, tag = "6")]
495        pub summary: ::core::option::Option<RevisionSummary>,
496    }
497    #[derive(serde::Serialize, serde::Deserialize)]
498    #[serde(rename_all = "snake_case")]
499    #[derive(Clone, PartialEq, ::prost::Message)]
500    pub struct Extension {
501        #[prost(message, optional, tag = "1")]
502        pub id: ::core::option::Option<::prost::alloc::string::String>,
503        #[prost(message, optional, tag = "2")]
504        pub name: ::core::option::Option<::prost::alloc::string::String>,
505        #[prost(message, optional, tag = "3")]
506        pub image: ::core::option::Option<::prost::alloc::string::String>,
507        #[prost(message, optional, tag = "4")]
508        pub dark_mode_image: ::core::option::Option<::prost::alloc::string::String>,
509        #[prost(message, repeated, tag = "5")]
510        pub revisions: ::prost::alloc::vec::Vec<Revision>,
511        #[prost(message, optional, tag = "6")]
512        pub is_hidden: ::core::option::Option<bool>,
513        #[prost(string, repeated, tag = "7")]
514        pub integrations: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
515        #[prost(string, repeated, tag = "8")]
516        pub keywords: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
517        #[prost(message, optional, tag = "9")]
518        pub deprecation: ::core::option::Option<super::Deprecation>,
519    }
520}
521#[derive(serde::Serialize, serde::Deserialize)]
522#[serde(rename_all = "snake_case")]
523#[derive(Clone, PartialEq, ::prost::Message)]
524pub struct GetExtensionRequest {
525    #[prost(message, optional, tag = "1")]
526    pub id: ::core::option::Option<::prost::alloc::string::String>,
527    /// On the frontend, we don't need the dashboard binaries.
528    /// But we need them for deployment in the extensions-service - so it's kind of a temporary argument,
529    /// As soon all the deployment logic is moved to the extensions-api, it can be removed.
530    #[prost(message, optional, tag = "2")]
531    pub include_dashboard_binaries: ::core::option::Option<bool>,
532    #[prost(message, optional, tag = "3")]
533    pub include_testing_revision: ::core::option::Option<bool>,
534}
535#[derive(serde::Serialize, serde::Deserialize)]
536#[serde(rename_all = "snake_case")]
537#[derive(Clone, PartialEq, ::prost::Message)]
538pub struct GetExtensionResponse {
539    #[prost(message, optional, tag = "1")]
540    pub extension: ::core::option::Option<Extension>,
541}
542/// Generated client implementations.
543pub mod extension_service_client {
544    #![allow(
545        unused_variables,
546        dead_code,
547        missing_docs,
548        clippy::wildcard_imports,
549        clippy::let_unit_value,
550    )]
551    use tonic::codegen::*;
552    use tonic::codegen::http::Uri;
553    #[derive(Debug, Clone)]
554    pub struct ExtensionServiceClient<T> {
555        inner: tonic::client::Grpc<T>,
556    }
557    impl ExtensionServiceClient<tonic::transport::Channel> {
558        /// Attempt to create a new client by connecting to a given endpoint.
559        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
560        where
561            D: TryInto<tonic::transport::Endpoint>,
562            D::Error: Into<StdError>,
563        {
564            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
565            Ok(Self::new(conn))
566        }
567    }
568    impl<T> ExtensionServiceClient<T>
569    where
570        T: tonic::client::GrpcService<tonic::body::BoxBody>,
571        T::Error: Into<StdError>,
572        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
573        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
574    {
575        pub fn new(inner: T) -> Self {
576            let inner = tonic::client::Grpc::new(inner);
577            Self { inner }
578        }
579        pub fn with_origin(inner: T, origin: Uri) -> Self {
580            let inner = tonic::client::Grpc::with_origin(inner, origin);
581            Self { inner }
582        }
583        pub fn with_interceptor<F>(
584            inner: T,
585            interceptor: F,
586        ) -> ExtensionServiceClient<InterceptedService<T, F>>
587        where
588            F: tonic::service::Interceptor,
589            T::ResponseBody: Default,
590            T: tonic::codegen::Service<
591                http::Request<tonic::body::BoxBody>,
592                Response = http::Response<
593                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
594                >,
595            >,
596            <T as tonic::codegen::Service<
597                http::Request<tonic::body::BoxBody>,
598            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
599        {
600            ExtensionServiceClient::new(InterceptedService::new(inner, interceptor))
601        }
602        /// Compress requests with the given encoding.
603        ///
604        /// This requires the server to support it otherwise it might respond with an
605        /// error.
606        #[must_use]
607        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
608            self.inner = self.inner.send_compressed(encoding);
609            self
610        }
611        /// Enable decompressing responses.
612        #[must_use]
613        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
614            self.inner = self.inner.accept_compressed(encoding);
615            self
616        }
617        /// Limits the maximum size of a decoded message.
618        ///
619        /// Default: `4MB`
620        #[must_use]
621        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
622            self.inner = self.inner.max_decoding_message_size(limit);
623            self
624        }
625        /// Limits the maximum size of an encoded message.
626        ///
627        /// Default: `usize::MAX`
628        #[must_use]
629        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
630            self.inner = self.inner.max_encoding_message_size(limit);
631            self
632        }
633        pub async fn get_all_extensions(
634            &mut self,
635            request: impl tonic::IntoRequest<super::GetAllExtensionsRequest>,
636        ) -> std::result::Result<
637            tonic::Response<super::GetAllExtensionsResponse>,
638            tonic::Status,
639        > {
640            self.inner
641                .ready()
642                .await
643                .map_err(|e| {
644                    tonic::Status::unknown(
645                        format!("Service was not ready: {}", e.into()),
646                    )
647                })?;
648            let codec = tonic::codec::ProstCodec::default();
649            let path = http::uri::PathAndQuery::from_static(
650                "/com.coralogix.extensions.v1.ExtensionService/GetAllExtensions",
651            );
652            let mut req = request.into_request();
653            req.extensions_mut()
654                .insert(
655                    GrpcMethod::new(
656                        "com.coralogix.extensions.v1.ExtensionService",
657                        "GetAllExtensions",
658                    ),
659                );
660            self.inner.unary(req, path, codec).await
661        }
662        pub async fn get_extension(
663            &mut self,
664            request: impl tonic::IntoRequest<super::GetExtensionRequest>,
665        ) -> std::result::Result<
666            tonic::Response<super::GetExtensionResponse>,
667            tonic::Status,
668        > {
669            self.inner
670                .ready()
671                .await
672                .map_err(|e| {
673                    tonic::Status::unknown(
674                        format!("Service was not ready: {}", e.into()),
675                    )
676                })?;
677            let codec = tonic::codec::ProstCodec::default();
678            let path = http::uri::PathAndQuery::from_static(
679                "/com.coralogix.extensions.v1.ExtensionService/GetExtension",
680            );
681            let mut req = request.into_request();
682            req.extensions_mut()
683                .insert(
684                    GrpcMethod::new(
685                        "com.coralogix.extensions.v1.ExtensionService",
686                        "GetExtension",
687                    ),
688                );
689            self.inner.unary(req, path, codec).await
690        }
691    }
692}
693#[derive(serde::Serialize, serde::Deserialize)]
694#[serde(rename_all = "snake_case")]
695#[derive(Clone, Copy, PartialEq, ::prost::Message)]
696pub struct GetDeployedExtensionsRequest {}
697#[derive(serde::Serialize, serde::Deserialize)]
698#[serde(rename_all = "snake_case")]
699#[derive(Clone, PartialEq, ::prost::Message)]
700pub struct GetDeployedExtensionsResponse {
701    #[prost(message, repeated, tag = "1")]
702    pub deployed_extensions: ::prost::alloc::vec::Vec<
703        get_deployed_extensions_response::DeployedExtension,
704    >,
705}
706/// Nested message and enum types in `GetDeployedExtensionsResponse`.
707pub mod get_deployed_extensions_response {
708    #[derive(serde::Serialize, serde::Deserialize)]
709    #[serde(rename_all = "snake_case")]
710    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
711    pub struct DeployedExtensionSummary {
712        #[prost(message, optional, tag = "1")]
713        pub deployed_item_counts: ::core::option::Option<super::ItemCounts>,
714    }
715    #[derive(serde::Serialize, serde::Deserialize)]
716    #[serde(rename_all = "snake_case")]
717    #[derive(Clone, PartialEq, ::prost::Message)]
718    pub struct DeployedExtension {
719        #[prost(message, optional, tag = "1")]
720        pub id: ::core::option::Option<::prost::alloc::string::String>,
721        #[prost(message, optional, tag = "2")]
722        pub version: ::core::option::Option<::prost::alloc::string::String>,
723        #[prost(message, repeated, tag = "3")]
724        pub applications: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
725        #[prost(message, repeated, tag = "4")]
726        pub subsystems: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
727        #[prost(message, repeated, tag = "5")]
728        pub item_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
729        #[prost(message, optional, tag = "6")]
730        pub summary: ::core::option::Option<DeployedExtensionSummary>,
731    }
732}
733#[derive(serde::Serialize, serde::Deserialize)]
734#[serde(rename_all = "snake_case")]
735#[derive(Clone, PartialEq, ::prost::Message)]
736pub struct ExtensionDeployment {
737    #[prost(message, optional, tag = "1")]
738    pub id: ::core::option::Option<::prost::alloc::string::String>,
739    #[prost(message, optional, tag = "2")]
740    pub version: ::core::option::Option<::prost::alloc::string::String>,
741    #[prost(message, repeated, tag = "3")]
742    pub item_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
743    #[prost(message, repeated, tag = "4")]
744    pub applications: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
745    #[prost(message, repeated, tag = "5")]
746    pub subsystems: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
747}
748#[derive(serde::Serialize, serde::Deserialize)]
749#[serde(rename_all = "snake_case")]
750#[derive(Clone, PartialEq, ::prost::Message)]
751pub struct DeployExtensionRequest {
752    #[prost(message, optional, tag = "1")]
753    pub id: ::core::option::Option<::prost::alloc::string::String>,
754    #[prost(message, optional, tag = "2")]
755    pub version: ::core::option::Option<::prost::alloc::string::String>,
756    #[prost(message, repeated, tag = "3")]
757    pub item_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
758    #[prost(message, repeated, tag = "4")]
759    pub applications: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
760    #[prost(message, repeated, tag = "5")]
761    pub subsystems: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
762    #[prost(message, optional, tag = "6")]
763    pub extension_deployment: ::core::option::Option<ExtensionDeployment>,
764}
765#[derive(serde::Serialize, serde::Deserialize)]
766#[serde(rename_all = "snake_case")]
767#[derive(Clone, PartialEq, ::prost::Message)]
768pub struct DeployExtensionResponse {
769    #[prost(message, optional, tag = "1")]
770    pub extension_deployment: ::core::option::Option<ExtensionDeployment>,
771}
772#[derive(serde::Serialize, serde::Deserialize)]
773#[serde(rename_all = "snake_case")]
774#[derive(Clone, PartialEq, ::prost::Message)]
775pub struct UpdateExtensionRequest {
776    #[prost(message, optional, tag = "1")]
777    pub id: ::core::option::Option<::prost::alloc::string::String>,
778    #[prost(message, optional, tag = "2")]
779    pub version: ::core::option::Option<::prost::alloc::string::String>,
780    #[prost(message, repeated, tag = "3")]
781    pub item_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
782    #[prost(message, repeated, tag = "4")]
783    pub applications: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
784    #[prost(message, repeated, tag = "5")]
785    pub subsystems: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
786    #[prost(message, optional, tag = "6")]
787    pub extension_deployment: ::core::option::Option<ExtensionDeployment>,
788}
789#[derive(serde::Serialize, serde::Deserialize)]
790#[serde(rename_all = "snake_case")]
791#[derive(Clone, PartialEq, ::prost::Message)]
792pub struct UpdateExtensionResponse {
793    #[prost(message, optional, tag = "1")]
794    pub extension_deployment: ::core::option::Option<ExtensionDeployment>,
795}
796#[derive(serde::Serialize, serde::Deserialize)]
797#[serde(rename_all = "snake_case")]
798#[derive(Clone, PartialEq, ::prost::Message)]
799pub struct UndeployExtensionRequest {
800    #[prost(message, optional, tag = "1")]
801    pub id: ::core::option::Option<::prost::alloc::string::String>,
802    #[prost(message, repeated, tag = "2")]
803    pub kept_extension_items: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
804}
805#[derive(serde::Serialize, serde::Deserialize)]
806#[serde(rename_all = "snake_case")]
807#[derive(Clone, PartialEq, ::prost::Message)]
808pub struct UndeployExtensionResponse {
809    #[prost(message, repeated, tag = "1")]
810    pub failed_items: ::prost::alloc::vec::Vec<undeploy_extension_response::FailedItem>,
811    #[prost(message, optional, tag = "2")]
812    pub extension_deployment: ::core::option::Option<ExtensionDeployment>,
813}
814/// Nested message and enum types in `UndeployExtensionResponse`.
815pub mod undeploy_extension_response {
816    #[derive(serde::Serialize, serde::Deserialize)]
817    #[serde(rename_all = "snake_case")]
818    #[derive(Clone, PartialEq, ::prost::Message)]
819    pub struct FailedItem {
820        #[prost(message, optional, tag = "1")]
821        pub item_id: ::core::option::Option<::prost::alloc::string::String>,
822        #[prost(message, optional, tag = "2")]
823        pub remote_id: ::core::option::Option<::prost::alloc::string::String>,
824        #[prost(message, optional, tag = "3")]
825        pub reason: ::core::option::Option<::prost::alloc::string::String>,
826    }
827}
828/// Generated client implementations.
829pub mod extension_deployment_service_client {
830    #![allow(
831        unused_variables,
832        dead_code,
833        missing_docs,
834        clippy::wildcard_imports,
835        clippy::let_unit_value,
836    )]
837    use tonic::codegen::*;
838    use tonic::codegen::http::Uri;
839    #[derive(Debug, Clone)]
840    pub struct ExtensionDeploymentServiceClient<T> {
841        inner: tonic::client::Grpc<T>,
842    }
843    impl ExtensionDeploymentServiceClient<tonic::transport::Channel> {
844        /// Attempt to create a new client by connecting to a given endpoint.
845        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
846        where
847            D: TryInto<tonic::transport::Endpoint>,
848            D::Error: Into<StdError>,
849        {
850            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
851            Ok(Self::new(conn))
852        }
853    }
854    impl<T> ExtensionDeploymentServiceClient<T>
855    where
856        T: tonic::client::GrpcService<tonic::body::BoxBody>,
857        T::Error: Into<StdError>,
858        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
859        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
860    {
861        pub fn new(inner: T) -> Self {
862            let inner = tonic::client::Grpc::new(inner);
863            Self { inner }
864        }
865        pub fn with_origin(inner: T, origin: Uri) -> Self {
866            let inner = tonic::client::Grpc::with_origin(inner, origin);
867            Self { inner }
868        }
869        pub fn with_interceptor<F>(
870            inner: T,
871            interceptor: F,
872        ) -> ExtensionDeploymentServiceClient<InterceptedService<T, F>>
873        where
874            F: tonic::service::Interceptor,
875            T::ResponseBody: Default,
876            T: tonic::codegen::Service<
877                http::Request<tonic::body::BoxBody>,
878                Response = http::Response<
879                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
880                >,
881            >,
882            <T as tonic::codegen::Service<
883                http::Request<tonic::body::BoxBody>,
884            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
885        {
886            ExtensionDeploymentServiceClient::new(
887                InterceptedService::new(inner, interceptor),
888            )
889        }
890        /// Compress requests with the given encoding.
891        ///
892        /// This requires the server to support it otherwise it might respond with an
893        /// error.
894        #[must_use]
895        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
896            self.inner = self.inner.send_compressed(encoding);
897            self
898        }
899        /// Enable decompressing responses.
900        #[must_use]
901        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
902            self.inner = self.inner.accept_compressed(encoding);
903            self
904        }
905        /// Limits the maximum size of a decoded message.
906        ///
907        /// Default: `4MB`
908        #[must_use]
909        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
910            self.inner = self.inner.max_decoding_message_size(limit);
911            self
912        }
913        /// Limits the maximum size of an encoded message.
914        ///
915        /// Default: `usize::MAX`
916        #[must_use]
917        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
918            self.inner = self.inner.max_encoding_message_size(limit);
919            self
920        }
921        pub async fn get_deployed_extensions(
922            &mut self,
923            request: impl tonic::IntoRequest<super::GetDeployedExtensionsRequest>,
924        ) -> std::result::Result<
925            tonic::Response<super::GetDeployedExtensionsResponse>,
926            tonic::Status,
927        > {
928            self.inner
929                .ready()
930                .await
931                .map_err(|e| {
932                    tonic::Status::unknown(
933                        format!("Service was not ready: {}", e.into()),
934                    )
935                })?;
936            let codec = tonic::codec::ProstCodec::default();
937            let path = http::uri::PathAndQuery::from_static(
938                "/com.coralogix.extensions.v1.ExtensionDeploymentService/GetDeployedExtensions",
939            );
940            let mut req = request.into_request();
941            req.extensions_mut()
942                .insert(
943                    GrpcMethod::new(
944                        "com.coralogix.extensions.v1.ExtensionDeploymentService",
945                        "GetDeployedExtensions",
946                    ),
947                );
948            self.inner.unary(req, path, codec).await
949        }
950        pub async fn deploy_extension(
951            &mut self,
952            request: impl tonic::IntoRequest<super::DeployExtensionRequest>,
953        ) -> std::result::Result<
954            tonic::Response<super::DeployExtensionResponse>,
955            tonic::Status,
956        > {
957            self.inner
958                .ready()
959                .await
960                .map_err(|e| {
961                    tonic::Status::unknown(
962                        format!("Service was not ready: {}", e.into()),
963                    )
964                })?;
965            let codec = tonic::codec::ProstCodec::default();
966            let path = http::uri::PathAndQuery::from_static(
967                "/com.coralogix.extensions.v1.ExtensionDeploymentService/DeployExtension",
968            );
969            let mut req = request.into_request();
970            req.extensions_mut()
971                .insert(
972                    GrpcMethod::new(
973                        "com.coralogix.extensions.v1.ExtensionDeploymentService",
974                        "DeployExtension",
975                    ),
976                );
977            self.inner.unary(req, path, codec).await
978        }
979        pub async fn update_extension(
980            &mut self,
981            request: impl tonic::IntoRequest<super::UpdateExtensionRequest>,
982        ) -> std::result::Result<
983            tonic::Response<super::UpdateExtensionResponse>,
984            tonic::Status,
985        > {
986            self.inner
987                .ready()
988                .await
989                .map_err(|e| {
990                    tonic::Status::unknown(
991                        format!("Service was not ready: {}", e.into()),
992                    )
993                })?;
994            let codec = tonic::codec::ProstCodec::default();
995            let path = http::uri::PathAndQuery::from_static(
996                "/com.coralogix.extensions.v1.ExtensionDeploymentService/UpdateExtension",
997            );
998            let mut req = request.into_request();
999            req.extensions_mut()
1000                .insert(
1001                    GrpcMethod::new(
1002                        "com.coralogix.extensions.v1.ExtensionDeploymentService",
1003                        "UpdateExtension",
1004                    ),
1005                );
1006            self.inner.unary(req, path, codec).await
1007        }
1008        pub async fn undeploy_extension(
1009            &mut self,
1010            request: impl tonic::IntoRequest<super::UndeployExtensionRequest>,
1011        ) -> std::result::Result<
1012            tonic::Response<super::UndeployExtensionResponse>,
1013            tonic::Status,
1014        > {
1015            self.inner
1016                .ready()
1017                .await
1018                .map_err(|e| {
1019                    tonic::Status::unknown(
1020                        format!("Service was not ready: {}", e.into()),
1021                    )
1022                })?;
1023            let codec = tonic::codec::ProstCodec::default();
1024            let path = http::uri::PathAndQuery::from_static(
1025                "/com.coralogix.extensions.v1.ExtensionDeploymentService/UndeployExtension",
1026            );
1027            let mut req = request.into_request();
1028            req.extensions_mut()
1029                .insert(
1030                    GrpcMethod::new(
1031                        "com.coralogix.extensions.v1.ExtensionDeploymentService",
1032                        "UndeployExtension",
1033                    ),
1034                );
1035            self.inner.unary(req, path, codec).await
1036        }
1037    }
1038}
1039#[derive(serde::Serialize, serde::Deserialize)]
1040#[serde(rename_all = "snake_case")]
1041#[derive(Clone, PartialEq, ::prost::Message)]
1042pub struct InitializeTestingRevisionRequest {
1043    #[prost(message, optional, tag = "1")]
1044    pub extension_data: ::core::option::Option<ExtensionData>,
1045}
1046#[derive(serde::Serialize, serde::Deserialize)]
1047#[serde(rename_all = "snake_case")]
1048#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1049pub struct InitializeTestingRevisionResponse {}
1050#[derive(serde::Serialize, serde::Deserialize)]
1051#[serde(rename_all = "snake_case")]
1052#[derive(Clone, PartialEq, ::prost::Message)]
1053pub struct CleanupTestingRevisionRequest {
1054    #[prost(message, optional, tag = "1")]
1055    pub id: ::core::option::Option<::prost::alloc::string::String>,
1056}
1057#[derive(serde::Serialize, serde::Deserialize)]
1058#[serde(rename_all = "snake_case")]
1059#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1060pub struct CleanupTestingRevisionResponse {}
1061#[derive(serde::Serialize, serde::Deserialize)]
1062#[serde(rename_all = "snake_case")]
1063#[derive(Clone, PartialEq, ::prost::Message)]
1064pub struct TestExtensionRevisionRequest {
1065    #[prost(message, optional, tag = "1")]
1066    pub extension_data: ::core::option::Option<ExtensionData>,
1067    #[prost(message, optional, tag = "2")]
1068    pub cleanup_after_test: ::core::option::Option<bool>,
1069}
1070#[derive(serde::Serialize, serde::Deserialize)]
1071#[serde(rename_all = "snake_case")]
1072#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1073pub struct TestExtensionRevisionResponse {}
1074/// Generated client implementations.
1075pub mod extension_testing_service_client {
1076    #![allow(
1077        unused_variables,
1078        dead_code,
1079        missing_docs,
1080        clippy::wildcard_imports,
1081        clippy::let_unit_value,
1082    )]
1083    use tonic::codegen::*;
1084    use tonic::codegen::http::Uri;
1085    #[derive(Debug, Clone)]
1086    pub struct ExtensionTestingServiceClient<T> {
1087        inner: tonic::client::Grpc<T>,
1088    }
1089    impl ExtensionTestingServiceClient<tonic::transport::Channel> {
1090        /// Attempt to create a new client by connecting to a given endpoint.
1091        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
1092        where
1093            D: TryInto<tonic::transport::Endpoint>,
1094            D::Error: Into<StdError>,
1095        {
1096            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
1097            Ok(Self::new(conn))
1098        }
1099    }
1100    impl<T> ExtensionTestingServiceClient<T>
1101    where
1102        T: tonic::client::GrpcService<tonic::body::BoxBody>,
1103        T::Error: Into<StdError>,
1104        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
1105        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
1106    {
1107        pub fn new(inner: T) -> Self {
1108            let inner = tonic::client::Grpc::new(inner);
1109            Self { inner }
1110        }
1111        pub fn with_origin(inner: T, origin: Uri) -> Self {
1112            let inner = tonic::client::Grpc::with_origin(inner, origin);
1113            Self { inner }
1114        }
1115        pub fn with_interceptor<F>(
1116            inner: T,
1117            interceptor: F,
1118        ) -> ExtensionTestingServiceClient<InterceptedService<T, F>>
1119        where
1120            F: tonic::service::Interceptor,
1121            T::ResponseBody: Default,
1122            T: tonic::codegen::Service<
1123                http::Request<tonic::body::BoxBody>,
1124                Response = http::Response<
1125                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
1126                >,
1127            >,
1128            <T as tonic::codegen::Service<
1129                http::Request<tonic::body::BoxBody>,
1130            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
1131        {
1132            ExtensionTestingServiceClient::new(
1133                InterceptedService::new(inner, interceptor),
1134            )
1135        }
1136        /// Compress requests with the given encoding.
1137        ///
1138        /// This requires the server to support it otherwise it might respond with an
1139        /// error.
1140        #[must_use]
1141        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
1142            self.inner = self.inner.send_compressed(encoding);
1143            self
1144        }
1145        /// Enable decompressing responses.
1146        #[must_use]
1147        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
1148            self.inner = self.inner.accept_compressed(encoding);
1149            self
1150        }
1151        /// Limits the maximum size of a decoded message.
1152        ///
1153        /// Default: `4MB`
1154        #[must_use]
1155        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
1156            self.inner = self.inner.max_decoding_message_size(limit);
1157            self
1158        }
1159        /// Limits the maximum size of an encoded message.
1160        ///
1161        /// Default: `usize::MAX`
1162        #[must_use]
1163        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
1164            self.inner = self.inner.max_encoding_message_size(limit);
1165            self
1166        }
1167        pub async fn initialize_testing_revision(
1168            &mut self,
1169            request: impl tonic::IntoRequest<super::InitializeTestingRevisionRequest>,
1170        ) -> std::result::Result<
1171            tonic::Response<super::InitializeTestingRevisionResponse>,
1172            tonic::Status,
1173        > {
1174            self.inner
1175                .ready()
1176                .await
1177                .map_err(|e| {
1178                    tonic::Status::unknown(
1179                        format!("Service was not ready: {}", e.into()),
1180                    )
1181                })?;
1182            let codec = tonic::codec::ProstCodec::default();
1183            let path = http::uri::PathAndQuery::from_static(
1184                "/com.coralogix.extensions.v1.ExtensionTestingService/InitializeTestingRevision",
1185            );
1186            let mut req = request.into_request();
1187            req.extensions_mut()
1188                .insert(
1189                    GrpcMethod::new(
1190                        "com.coralogix.extensions.v1.ExtensionTestingService",
1191                        "InitializeTestingRevision",
1192                    ),
1193                );
1194            self.inner.unary(req, path, codec).await
1195        }
1196        pub async fn cleanup_testing_revision(
1197            &mut self,
1198            request: impl tonic::IntoRequest<super::CleanupTestingRevisionRequest>,
1199        ) -> std::result::Result<
1200            tonic::Response<super::CleanupTestingRevisionResponse>,
1201            tonic::Status,
1202        > {
1203            self.inner
1204                .ready()
1205                .await
1206                .map_err(|e| {
1207                    tonic::Status::unknown(
1208                        format!("Service was not ready: {}", e.into()),
1209                    )
1210                })?;
1211            let codec = tonic::codec::ProstCodec::default();
1212            let path = http::uri::PathAndQuery::from_static(
1213                "/com.coralogix.extensions.v1.ExtensionTestingService/CleanupTestingRevision",
1214            );
1215            let mut req = request.into_request();
1216            req.extensions_mut()
1217                .insert(
1218                    GrpcMethod::new(
1219                        "com.coralogix.extensions.v1.ExtensionTestingService",
1220                        "CleanupTestingRevision",
1221                    ),
1222                );
1223            self.inner.unary(req, path, codec).await
1224        }
1225        pub async fn test_extension_revision(
1226            &mut self,
1227            request: impl tonic::IntoRequest<super::TestExtensionRevisionRequest>,
1228        ) -> std::result::Result<
1229            tonic::Response<super::TestExtensionRevisionResponse>,
1230            tonic::Status,
1231        > {
1232            self.inner
1233                .ready()
1234                .await
1235                .map_err(|e| {
1236                    tonic::Status::unknown(
1237                        format!("Service was not ready: {}", e.into()),
1238                    )
1239                })?;
1240            let codec = tonic::codec::ProstCodec::default();
1241            let path = http::uri::PathAndQuery::from_static(
1242                "/com.coralogix.extensions.v1.ExtensionTestingService/TestExtensionRevision",
1243            );
1244            let mut req = request.into_request();
1245            req.extensions_mut()
1246                .insert(
1247                    GrpcMethod::new(
1248                        "com.coralogix.extensions.v1.ExtensionTestingService",
1249                        "TestExtensionRevision",
1250                    ),
1251                );
1252            self.inner.unary(req, path, codec).await
1253        }
1254    }
1255}