1#[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}
13pub 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 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 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}
92pub 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 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 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}
219pub 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 pub fn as_str_name(&self) -> &'static str {
244 match self {
245 Self::KibanaIndexPattern => "KIBANA_INDEX_PATTERN",
246 }
247 }
248 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#[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 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 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}
452pub 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}
469pub 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 #[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}
542pub 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 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 #[must_use]
607 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
608 self.inner = self.inner.send_compressed(encoding);
609 self
610 }
611 #[must_use]
613 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
614 self.inner = self.inner.accept_compressed(encoding);
615 self
616 }
617 #[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 #[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}
706pub 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}
814pub 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}
828pub 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 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 #[must_use]
895 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
896 self.inner = self.inner.send_compressed(encoding);
897 self
898 }
899 #[must_use]
901 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
902 self.inner = self.inner.accept_compressed(encoding);
903 self
904 }
905 #[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 #[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 {}
1074pub 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 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 #[must_use]
1141 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
1142 self.inner = self.inner.send_compressed(encoding);
1143 self
1144 }
1145 #[must_use]
1147 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
1148 self.inner = self.inner.accept_compressed(encoding);
1149 self
1150 }
1151 #[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 #[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}