1#[derive(serde::Serialize, serde::Deserialize)]
3#[serde(rename_all = "snake_case")]
4#[derive(Clone, PartialEq, ::prost::Message)]
5pub struct CloudFormationStack {
6 #[prost(message, optional, tag = "1")]
7 pub arn: ::core::option::Option<::prost::alloc::string::String>,
8 #[prost(message, optional, tag = "2")]
9 pub region: ::core::option::Option<::prost::alloc::string::String>,
10}
11#[derive(serde::Serialize, serde::Deserialize)]
12#[serde(rename_all = "snake_case")]
13#[derive(Clone, PartialEq, ::prost::Message)]
14pub struct ArmStack {
15 #[prost(message, optional, tag = "1")]
16 pub subscription_id: ::core::option::Option<::prost::alloc::string::String>,
17 #[prost(message, optional, tag = "2")]
18 pub resource_group_name: ::core::option::Option<::prost::alloc::string::String>,
19}
20#[derive(serde::Serialize, serde::Deserialize)]
21#[serde(rename_all = "snake_case")]
22#[derive(Clone, Copy, PartialEq, ::prost::Message)]
23pub struct NoDeployment {}
24#[derive(serde::Serialize, serde::Deserialize)]
25#[serde(rename_all = "snake_case")]
26#[derive(Clone, PartialEq, ::prost::Message)]
27pub struct IntegrationStatus {
28 #[prost(enumeration = "ConnectionStatus", tag = "1")]
29 pub connection_status: i32,
30 #[prost(map = "string, string", tag = "3")]
31 pub details: ::std::collections::HashMap<
32 ::prost::alloc::string::String,
33 ::prost::alloc::string::String,
34 >,
35 #[prost(message, repeated, tag = "4")]
36 pub messages: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
37}
38#[derive(serde::Serialize, serde::Deserialize)]
39#[serde(rename_all = "snake_case")]
40#[derive(Clone, PartialEq, ::prost::Message)]
41pub struct IntegrationDoc {
42 #[prost(message, optional, tag = "1")]
43 pub name: ::core::option::Option<::prost::alloc::string::String>,
44 #[prost(message, optional, tag = "2")]
45 pub link: ::core::option::Option<::prost::alloc::string::String>,
46}
47#[derive(serde::Serialize, serde::Deserialize)]
48#[serde(rename_all = "snake_case")]
49#[derive(Clone, Copy, PartialEq, ::prost::Message)]
50pub struct IntegrationType {
51 #[prost(oneof = "integration_type::IntegrationType", tags = "1, 2, 3, 4, 5, 6, 7")]
52 pub integration_type: ::core::option::Option<integration_type::IntegrationType>,
53}
54pub mod integration_type {
56 #[derive(serde::Serialize, serde::Deserialize)]
57 #[serde(rename_all = "snake_case")]
58 #[derive(Clone, Copy, PartialEq, ::prost::Message)]
59 pub struct Managed {
60 #[prost(enumeration = "managed::Variant", tag = "2")]
61 pub variant: i32,
62 }
63 pub mod managed {
65 #[derive(serde::Serialize, serde::Deserialize)]
66 #[serde(rename_all = "snake_case")]
67 #[derive(
68 Clone,
69 Copy,
70 Debug,
71 PartialEq,
72 Eq,
73 Hash,
74 PartialOrd,
75 Ord,
76 ::prost::Enumeration
77 )]
78 #[repr(i32)]
79 pub enum Variant {
80 Default = 0,
81 Gcp = 1,
82 Oauth = 2,
83 Custom = 3,
84 }
85 impl Variant {
86 pub fn as_str_name(&self) -> &'static str {
91 match self {
92 Self::Default => "DEFAULT",
93 Self::Gcp => "GCP",
94 Self::Oauth => "OAUTH",
95 Self::Custom => "CUSTOM",
96 }
97 }
98 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
100 match value {
101 "DEFAULT" => Some(Self::Default),
102 "GCP" => Some(Self::Gcp),
103 "OAUTH" => Some(Self::Oauth),
104 "CUSTOM" => Some(Self::Custom),
105 _ => None,
106 }
107 }
108 }
109 }
110 #[derive(serde::Serialize, serde::Deserialize)]
111 #[serde(rename_all = "snake_case")]
112 #[derive(Clone, Copy, PartialEq, ::prost::Message)]
113 pub struct Untracked {}
114 #[derive(serde::Serialize, serde::Deserialize)]
115 #[serde(rename_all = "snake_case")]
116 #[derive(Clone, Copy, PartialEq, ::prost::Message)]
117 pub struct Cloudformation {}
118 #[derive(serde::Serialize, serde::Deserialize)]
119 #[serde(rename_all = "snake_case")]
120 #[derive(Clone, Copy, PartialEq, ::prost::Message)]
121 pub struct AzureArm {}
122 #[derive(serde::Serialize, serde::Deserialize)]
126 #[serde(rename_all = "snake_case")]
127 #[derive(Clone, Copy, PartialEq, ::prost::Message)]
128 pub struct PushBasedContextualData {}
129 #[derive(serde::Serialize, serde::Deserialize)]
130 #[serde(rename_all = "snake_case")]
131 #[derive(Clone, Copy, PartialEq, ::prost::Message)]
132 pub struct ContextualData {}
133 #[derive(serde::Serialize, serde::Deserialize)]
134 #[serde(rename_all = "snake_case")]
135 #[derive(Clone, Copy, PartialEq, ::prost::Message)]
136 pub struct GenericWebhook {}
137 #[derive(serde::Serialize, serde::Deserialize)]
138 #[serde(rename_all = "snake_case")]
139 #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
140 pub enum IntegrationType {
141 #[prost(message, tag = "1")]
142 Managed(Managed),
143 #[prost(message, tag = "2")]
144 Untracked(Untracked),
145 #[prost(message, tag = "3")]
146 Cloudformation(Cloudformation),
147 #[prost(message, tag = "4")]
148 Arm(AzureArm),
149 #[prost(message, tag = "5")]
150 PushBasedContextualData(PushBasedContextualData),
151 #[prost(message, tag = "6")]
152 ContextualData(ContextualData),
153 #[prost(message, tag = "7")]
154 GenericWebhook(GenericWebhook),
155 }
156}
157#[derive(serde::Serialize, serde::Deserialize)]
158#[serde(rename_all = "snake_case")]
159#[derive(Clone, PartialEq, ::prost::Message)]
160pub struct Integration {
161 #[prost(message, optional, tag = "1")]
163 pub id: ::core::option::Option<::prost::alloc::string::String>,
164 #[prost(message, optional, tag = "2")]
165 pub name: ::core::option::Option<::prost::alloc::string::String>,
166 #[prost(message, optional, tag = "3")]
167 pub description: ::core::option::Option<::prost::alloc::string::String>,
168 #[prost(message, optional, tag = "4")]
169 pub icon: ::core::option::Option<::prost::alloc::string::String>,
170 #[prost(message, optional, tag = "5")]
171 pub dark_icon: ::core::option::Option<::prost::alloc::string::String>,
172 #[prost(message, repeated, tag = "7")]
173 pub tags: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
174 #[prost(message, repeated, tag = "8")]
175 pub versions: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
176 #[prost(message, optional, tag = "9")]
177 pub integration_type: ::core::option::Option<IntegrationType>,
178 #[prost(message, optional, tag = "10")]
179 pub feature_flag: ::core::option::Option<::prost::alloc::string::String>,
180}
181#[derive(serde::Serialize, serde::Deserialize)]
182#[serde(rename_all = "snake_case")]
183#[derive(Clone, PartialEq, ::prost::Message)]
184pub struct RevisionRef {
185 #[prost(string, tag = "1")]
187 pub version: ::prost::alloc::string::String,
188 #[prost(string, tag = "2")]
189 pub description_md: ::prost::alloc::string::String,
190}
191#[derive(serde::Serialize, serde::Deserialize)]
192#[serde(rename_all = "snake_case")]
193#[derive(Clone, PartialEq, ::prost::Message)]
194pub struct LocalChangelog {
195 #[prost(message, repeated, tag = "1")]
196 pub changes: ::prost::alloc::vec::Vec<RevisionRef>,
197}
198#[derive(serde::Serialize, serde::Deserialize)]
199#[serde(rename_all = "snake_case")]
200#[derive(Clone, PartialEq, ::prost::Message)]
201pub struct ExternalUrl {
202 #[prost(string, tag = "1")]
203 pub url: ::prost::alloc::string::String,
204}
205#[derive(serde::Serialize, serde::Deserialize)]
206#[serde(rename_all = "snake_case")]
207#[derive(Clone, PartialEq, ::prost::Message)]
208pub struct IntegrationDetails {
209 #[prost(message, optional, tag = "1")]
210 pub integration: ::core::option::Option<Integration>,
211 #[prost(message, repeated, tag = "3")]
212 pub extensions: ::prost::alloc::vec::Vec<super::super::extensions::v1::Extension>,
213 #[prost(message, repeated, tag = "4")]
214 pub docs: ::prost::alloc::vec::Vec<IntegrationDoc>,
215 #[prost(oneof = "integration_details::IntegrationTypeDetails", tags = "500")]
216 pub integration_type_details: ::core::option::Option<
217 integration_details::IntegrationTypeDetails,
218 >,
219 #[prost(oneof = "integration_details::Changelog", tags = "201, 202")]
220 pub changelog: ::core::option::Option<integration_details::Changelog>,
221}
222pub mod integration_details {
224 #[derive(serde::Serialize, serde::Deserialize)]
225 #[serde(rename_all = "snake_case")]
226 #[derive(Clone, PartialEq, ::prost::Message)]
227 pub struct DefaultIntegrationDetails {
228 #[prost(message, repeated, tag = "1")]
229 pub registered: ::prost::alloc::vec::Vec<
230 default_integration_details::RegisteredInstance,
231 >,
232 }
233 pub mod default_integration_details {
235 #[derive(serde::Serialize, serde::Deserialize)]
236 #[serde(rename_all = "snake_case")]
237 #[derive(Clone, PartialEq, ::prost::Message)]
238 pub struct RegisteredInstance {
239 #[prost(message, optional, tag = "1")]
240 pub id: ::core::option::Option<::prost::alloc::string::String>,
241 #[prost(message, optional, tag = "2")]
242 pub definition_version: ::core::option::Option<
243 ::prost::alloc::string::String,
244 >,
245 #[prost(message, optional, tag = "3")]
246 pub last_updated: ::core::option::Option<::prost_wkt_types::Timestamp>,
247 #[prost(message, repeated, tag = "4")]
248 pub parameters: ::prost::alloc::vec::Vec<super::super::Parameter>,
249 #[prost(message, optional, tag = "7")]
250 pub integration_status: ::core::option::Option<
251 super::super::IntegrationStatus,
252 >,
253 #[prost(message, optional, tag = "8")]
254 pub is_testing: ::core::option::Option<bool>,
255 #[prost(oneof = "registered_instance::Deployment", tags = "100, 101, 102")]
256 pub deployment: ::core::option::Option<registered_instance::Deployment>,
257 }
258 pub mod registered_instance {
260 #[derive(serde::Serialize, serde::Deserialize)]
261 #[serde(rename_all = "snake_case")]
262 #[derive(Clone, PartialEq, ::prost::Oneof)]
263 pub enum Deployment {
264 #[prost(message, tag = "100")]
265 Empty(super::super::super::NoDeployment),
266 #[prost(message, tag = "101")]
267 Cloudformation(super::super::super::CloudFormationStack),
268 #[prost(message, tag = "102")]
269 Arm(super::super::super::ArmStack),
270 }
271 }
272 }
273 #[derive(serde::Serialize, serde::Deserialize)]
274 #[serde(rename_all = "snake_case")]
275 #[derive(Clone, PartialEq, ::prost::Oneof)]
276 pub enum IntegrationTypeDetails {
277 #[prost(message, tag = "500")]
278 Default(DefaultIntegrationDetails),
279 }
280 #[derive(serde::Serialize, serde::Deserialize)]
281 #[serde(rename_all = "snake_case")]
282 #[derive(Clone, PartialEq, ::prost::Oneof)]
283 pub enum Changelog {
284 #[prost(message, tag = "201")]
285 Local(super::LocalChangelog),
286 #[prost(message, tag = "202")]
287 External(super::ExternalUrl),
288 }
289}
290#[derive(serde::Serialize, serde::Deserialize)]
291#[serde(rename_all = "snake_case")]
292#[derive(Clone, PartialEq, ::prost::Message)]
293pub struct IntegrationDefinition {
294 #[prost(message, optional, tag = "1")]
296 pub key: ::core::option::Option<::prost::alloc::string::String>,
297 #[prost(message, optional, tag = "2")]
298 pub integration_type: ::core::option::Option<IntegrationType>,
299 #[prost(message, repeated, tag = "3")]
300 pub revisions: ::prost::alloc::vec::Vec<IntegrationRevision>,
301 #[prost(message, optional, tag = "4")]
302 pub feature_flag: ::core::option::Option<::prost::alloc::string::String>,
303}
304#[derive(serde::Serialize, serde::Deserialize)]
305#[serde(rename_all = "snake_case")]
306#[derive(Clone, PartialEq, ::prost::Message)]
307pub struct IntegrationRevision {
308 #[prost(message, optional, tag = "1")]
310 pub id: ::core::option::Option<::prost::alloc::string::String>,
311 #[prost(message, repeated, tag = "3")]
312 pub fields: ::prost::alloc::vec::Vec<integration_revision::FieldInformation>,
313 #[prost(message, repeated, tag = "4")]
314 pub groups: ::prost::alloc::vec::Vec<integration_revision::Group>,
315 #[prost(string, optional, tag = "5")]
316 pub upgrade_instructions_md: ::core::option::Option<::prost::alloc::string::String>,
317 #[prost(bool, tag = "6")]
318 pub revision_deployment_supported: bool,
319 #[prost(message, optional, tag = "7")]
320 pub feature_flag: ::core::option::Option<::prost::alloc::string::String>,
321 #[prost(
322 oneof = "integration_revision::DeploymentMethod",
323 tags = "101, 102, 103, 104, 105, 106"
324 )]
325 pub deployment_method: ::core::option::Option<
326 integration_revision::DeploymentMethod,
327 >,
328}
329pub mod integration_revision {
331 #[derive(serde::Serialize, serde::Deserialize)]
332 #[serde(rename_all = "snake_case")]
333 #[derive(Clone, PartialEq, ::prost::Message)]
334 pub struct CloudFormationTemplate {
335 #[prost(message, optional, tag = "1")]
336 pub template_url: ::core::option::Option<::prost::alloc::string::String>,
337 #[prost(map = "string, string", tag = "2")]
338 pub parameters: ::std::collections::HashMap<
339 ::prost::alloc::string::String,
340 ::prost::alloc::string::String,
341 >,
342 #[prost(map = "string, string", tag = "3")]
343 pub post_installation_steps: ::std::collections::HashMap<
344 ::prost::alloc::string::String,
345 ::prost::alloc::string::String,
346 >,
347 #[prost(message, repeated, tag = "4")]
348 pub commands: ::prost::alloc::vec::Vec<CommandInformation>,
349 }
350 #[derive(serde::Serialize, serde::Deserialize)]
351 #[serde(rename_all = "snake_case")]
352 #[derive(Clone, Copy, PartialEq, ::prost::Message)]
353 pub struct ManagedService {}
354 #[derive(serde::Serialize, serde::Deserialize)]
355 #[serde(rename_all = "snake_case")]
356 #[derive(Clone, PartialEq, ::prost::Message)]
357 pub struct HelmChart {
358 #[prost(message, optional, tag = "1")]
359 pub template: ::core::option::Option<::prost::alloc::string::String>,
360 #[prost(message, repeated, tag = "2")]
361 pub commands: ::prost::alloc::vec::Vec<CommandInformation>,
362 #[prost(message, optional, tag = "3")]
363 pub guide: ::core::option::Option<IntegrationGuide>,
364 }
365 #[derive(serde::Serialize, serde::Deserialize)]
366 #[serde(rename_all = "snake_case")]
367 #[derive(Clone, PartialEq, ::prost::Message)]
368 pub struct Terraform {
369 #[prost(message, repeated, tag = "1")]
370 pub configuration_blocks: ::prost::alloc::vec::Vec<ConfigurationBlock>,
371 }
372 #[derive(serde::Serialize, serde::Deserialize)]
373 #[serde(rename_all = "snake_case")]
374 #[derive(Clone, PartialEq, ::prost::Message)]
375 pub struct Rum {
376 #[prost(message, repeated, tag = "1")]
377 pub browser_sdk_commands: ::prost::alloc::vec::Vec<CommandInformation>,
378 #[prost(message, repeated, tag = "2")]
379 pub source_map_commands: ::prost::alloc::vec::Vec<CommandInformation>,
380 }
381 #[derive(serde::Serialize, serde::Deserialize)]
382 #[serde(rename_all = "snake_case")]
383 #[derive(Clone, PartialEq, ::prost::Message)]
384 pub struct AzureArmTemplate {
385 #[prost(message, optional, tag = "1")]
386 pub template_url: ::core::option::Option<::prost::alloc::string::String>,
387 }
388 #[derive(serde::Serialize, serde::Deserialize)]
389 #[serde(rename_all = "snake_case")]
390 #[derive(Clone, PartialEq, ::prost::Message)]
391 pub struct ListTextValue {
392 #[prost(message, repeated, tag = "2")]
393 pub options: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
394 #[prost(message, repeated, tag = "4")]
395 pub default_values: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
396 }
397 #[derive(serde::Serialize, serde::Deserialize)]
398 #[serde(rename_all = "snake_case")]
399 #[derive(Clone, PartialEq, ::prost::Message)]
400 pub struct SingleValue {
401 #[prost(message, optional, tag = "1")]
402 pub default_value: ::core::option::Option<::prost::alloc::string::String>,
403 }
404 #[derive(serde::Serialize, serde::Deserialize)]
405 #[serde(rename_all = "snake_case")]
406 #[derive(Clone, Copy, PartialEq, ::prost::Message)]
407 pub struct SingleBooleanValue {
408 #[prost(message, optional, tag = "1")]
409 pub default_value: ::core::option::Option<bool>,
410 }
411 #[derive(serde::Serialize, serde::Deserialize)]
412 #[serde(rename_all = "snake_case")]
413 #[derive(Clone, Copy, PartialEq, ::prost::Message)]
414 pub struct SingleNumericValue {
415 #[prost(message, optional, tag = "1")]
416 pub default_value: ::core::option::Option<f64>,
417 }
418 #[derive(serde::Serialize, serde::Deserialize)]
419 #[serde(rename_all = "snake_case")]
420 #[derive(Clone, PartialEq, ::prost::Message)]
421 pub struct MultipleSelectionValue {
422 #[prost(message, repeated, tag = "1")]
423 pub options: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
424 }
425 #[derive(serde::Serialize, serde::Deserialize)]
426 #[serde(rename_all = "snake_case")]
427 #[derive(Clone, PartialEq, ::prost::Message)]
428 pub struct SelectionValue {
429 #[prost(message, repeated, tag = "1")]
430 pub options: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
431 #[prost(message, optional, tag = "2")]
432 pub default_value: ::core::option::Option<::prost::alloc::string::String>,
433 }
434 #[derive(serde::Serialize, serde::Deserialize)]
435 #[serde(rename_all = "snake_case")]
436 #[derive(Clone, PartialEq, ::prost::Message)]
437 pub struct FieldCondition {
438 #[prost(enumeration = "field_condition::ConditionType", tag = "1")]
439 pub r#type: i32,
440 #[prost(message, repeated, tag = "2")]
441 pub values: ::prost::alloc::vec::Vec<field_condition::FieldValue>,
442 }
443 pub mod field_condition {
445 #[derive(serde::Serialize, serde::Deserialize)]
446 #[serde(rename_all = "snake_case")]
447 #[derive(Clone, PartialEq, ::prost::Message)]
448 pub struct FieldValue {
449 #[prost(string, tag = "1")]
450 pub field_name: ::prost::alloc::string::String,
451 #[prost(string, tag = "2")]
452 pub value_pattern: ::prost::alloc::string::String,
453 }
454 #[derive(serde::Serialize, serde::Deserialize)]
455 #[serde(rename_all = "snake_case")]
456 #[derive(
457 Clone,
458 Copy,
459 Debug,
460 PartialEq,
461 Eq,
462 Hash,
463 PartialOrd,
464 Ord,
465 ::prost::Enumeration
466 )]
467 #[repr(i32)]
468 pub enum ConditionType {
469 Unknown = 0,
470 Or = 1,
471 And = 2,
472 }
473 impl ConditionType {
474 pub fn as_str_name(&self) -> &'static str {
479 match self {
480 Self::Unknown => "UNKNOWN",
481 Self::Or => "OR",
482 Self::And => "AND",
483 }
484 }
485 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
487 match value {
488 "UNKNOWN" => Some(Self::Unknown),
489 "OR" => Some(Self::Or),
490 "AND" => Some(Self::And),
491 _ => None,
492 }
493 }
494 }
495 }
496 #[derive(serde::Serialize, serde::Deserialize)]
497 #[serde(rename_all = "snake_case")]
498 #[derive(Clone, PartialEq, ::prost::Message)]
499 pub struct Group {
500 #[prost(message, optional, tag = "1")]
501 pub id: ::core::option::Option<::prost::alloc::string::String>,
502 #[prost(message, optional, tag = "2")]
503 pub name: ::core::option::Option<::prost::alloc::string::String>,
504 }
505 #[derive(serde::Serialize, serde::Deserialize)]
506 #[serde(rename_all = "snake_case")]
507 #[derive(Clone, PartialEq, ::prost::Message)]
508 pub struct FieldInformation {
509 #[prost(enumeration = "InputType", tag = "1")]
510 pub r#type: i32,
511 #[prost(message, optional, tag = "2")]
512 pub name: ::core::option::Option<::prost::alloc::string::String>,
513 #[prost(message, optional, tag = "3")]
514 pub tooltip: ::core::option::Option<::prost::alloc::string::String>,
515 #[prost(message, optional, tag = "4")]
516 pub template_param_name: ::core::option::Option<::prost::alloc::string::String>,
517 #[prost(message, optional, tag = "5")]
518 pub placeholder: ::core::option::Option<::prost::alloc::string::String>,
519 #[prost(message, optional, tag = "6")]
520 pub required: ::core::option::Option<bool>,
521 #[prost(message, optional, tag = "7")]
522 pub predefined: ::core::option::Option<bool>,
523 #[prost(message, optional, tag = "8")]
524 pub visible: ::core::option::Option<bool>,
525 #[prost(message, optional, tag = "9")]
526 pub readonly: ::core::option::Option<bool>,
527 #[prost(message, optional, tag = "10")]
528 pub applicable_if: ::core::option::Option<FieldCondition>,
529 #[prost(message, optional, tag = "11")]
530 pub group_id: ::core::option::Option<::prost::alloc::string::String>,
531 #[prost(message, optional, tag = "12")]
532 pub upgrade_notice: ::core::option::Option<::prost::alloc::string::String>,
533 #[prost(message, optional, tag = "13")]
534 pub allowed_pattern: ::core::option::Option<::prost::alloc::string::String>,
535 #[prost(message, optional, tag = "14")]
536 pub documentation_reference: ::core::option::Option<
537 ::prost::alloc::string::String,
538 >,
539 #[prost(
540 oneof = "field_information::Value",
541 tags = "101, 102, 103, 104, 105, 106"
542 )]
543 pub value: ::core::option::Option<field_information::Value>,
544 }
545 pub mod field_information {
547 #[derive(serde::Serialize, serde::Deserialize)]
548 #[serde(rename_all = "snake_case")]
549 #[derive(Clone, PartialEq, ::prost::Oneof)]
550 pub enum Value {
551 #[prost(message, tag = "101")]
552 Single(super::SingleValue),
553 #[prost(message, tag = "102")]
554 MultiText(super::ListTextValue),
555 #[prost(message, tag = "103")]
556 MultipleSelection(super::MultipleSelectionValue),
557 #[prost(message, tag = "104")]
558 SingleBoolean(super::SingleBooleanValue),
559 #[prost(message, tag = "105")]
560 Selection(super::SelectionValue),
561 #[prost(message, tag = "106")]
562 SingleNumber(super::SingleNumericValue),
563 }
564 }
565 #[derive(serde::Serialize, serde::Deserialize)]
566 #[serde(rename_all = "snake_case")]
567 #[derive(Clone, PartialEq, ::prost::Message)]
568 pub struct CommandInformation {
569 #[prost(message, optional, tag = "1")]
570 pub name: ::core::option::Option<::prost::alloc::string::String>,
571 #[prost(message, optional, tag = "2")]
572 pub command: ::core::option::Option<::prost::alloc::string::String>,
573 #[prost(message, optional, tag = "3")]
574 pub description: ::core::option::Option<::prost::alloc::string::String>,
575 #[prost(message, optional, tag = "4")]
576 pub tooltip_text: ::core::option::Option<::prost::alloc::string::String>,
577 #[prost(enumeration = "command_information::Language", optional, tag = "5")]
578 pub language: ::core::option::Option<i32>,
579 #[prost(message, repeated, tag = "6")]
580 pub links: ::prost::alloc::vec::Vec<command_information::Link>,
581 }
582 pub mod command_information {
584 #[derive(serde::Serialize, serde::Deserialize)]
585 #[serde(rename_all = "snake_case")]
586 #[derive(Clone, PartialEq, ::prost::Message)]
587 pub struct Link {
588 #[prost(string, tag = "1")]
589 pub key: ::prost::alloc::string::String,
590 #[prost(string, tag = "2")]
591 pub text: ::prost::alloc::string::String,
592 #[prost(string, tag = "3")]
593 pub url: ::prost::alloc::string::String,
594 }
595 #[derive(serde::Serialize, serde::Deserialize)]
596 #[serde(rename_all = "snake_case")]
597 #[derive(
598 Clone,
599 Copy,
600 Debug,
601 PartialEq,
602 Eq,
603 Hash,
604 PartialOrd,
605 Ord,
606 ::prost::Enumeration
607 )]
608 #[repr(i32)]
609 pub enum Language {
610 Unknown = 0,
611 Bash = 1,
612 Javascript = 2,
613 }
614 impl Language {
615 pub fn as_str_name(&self) -> &'static str {
620 match self {
621 Self::Unknown => "UNKNOWN",
622 Self::Bash => "BASH",
623 Self::Javascript => "JAVASCRIPT",
624 }
625 }
626 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
628 match value {
629 "UNKNOWN" => Some(Self::Unknown),
630 "BASH" => Some(Self::Bash),
631 "JAVASCRIPT" => Some(Self::Javascript),
632 _ => None,
633 }
634 }
635 }
636 }
637 #[derive(serde::Serialize, serde::Deserialize)]
638 #[serde(rename_all = "snake_case")]
639 #[derive(Clone, PartialEq, ::prost::Message)]
640 pub struct ConfigurationBlock {
641 #[prost(message, optional, tag = "1")]
642 pub name: ::core::option::Option<::prost::alloc::string::String>,
643 #[prost(message, optional, tag = "2")]
644 pub value: ::core::option::Option<::prost::alloc::string::String>,
645 #[prost(message, optional, tag = "3")]
646 pub description: ::core::option::Option<::prost::alloc::string::String>,
647 }
648 #[derive(serde::Serialize, serde::Deserialize)]
649 #[serde(rename_all = "snake_case")]
650 #[derive(Clone, PartialEq, ::prost::Message)]
651 pub struct IntegrationGuide {
652 #[prost(message, optional, tag = "1")]
653 pub introduction: ::core::option::Option<::prost::alloc::string::String>,
654 #[prost(message, optional, tag = "2")]
655 pub installation_requirements: ::core::option::Option<
656 ::prost::alloc::string::String,
657 >,
658 }
659 #[derive(serde::Serialize, serde::Deserialize)]
660 #[serde(rename_all = "snake_case")]
661 #[derive(
662 Clone,
663 Copy,
664 Debug,
665 PartialEq,
666 Eq,
667 Hash,
668 PartialOrd,
669 Ord,
670 ::prost::Enumeration
671 )]
672 #[repr(i32)]
673 pub enum InputType {
674 ApiKey = 0,
675 Text = 1,
676 ListText = 2,
677 MultipleSelection = 3,
678 Boolean = 4,
679 Select = 5,
680 Json = 6,
681 Number = 7,
682 SensitiveData = 8,
683 JsonObjectArray = 9,
684 }
685 impl InputType {
686 pub fn as_str_name(&self) -> &'static str {
691 match self {
692 Self::ApiKey => "API_KEY",
693 Self::Text => "TEXT",
694 Self::ListText => "LIST_TEXT",
695 Self::MultipleSelection => "MULTIPLE_SELECTION",
696 Self::Boolean => "BOOLEAN",
697 Self::Select => "SELECT",
698 Self::Json => "JSON",
699 Self::Number => "NUMBER",
700 Self::SensitiveData => "SENSITIVE_DATA",
701 Self::JsonObjectArray => "JSON_OBJECT_ARRAY",
702 }
703 }
704 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
706 match value {
707 "API_KEY" => Some(Self::ApiKey),
708 "TEXT" => Some(Self::Text),
709 "LIST_TEXT" => Some(Self::ListText),
710 "MULTIPLE_SELECTION" => Some(Self::MultipleSelection),
711 "BOOLEAN" => Some(Self::Boolean),
712 "SELECT" => Some(Self::Select),
713 "JSON" => Some(Self::Json),
714 "NUMBER" => Some(Self::Number),
715 "SENSITIVE_DATA" => Some(Self::SensitiveData),
716 "JSON_OBJECT_ARRAY" => Some(Self::JsonObjectArray),
717 _ => None,
718 }
719 }
720 }
721 #[derive(serde::Serialize, serde::Deserialize)]
722 #[serde(rename_all = "snake_case")]
723 #[derive(Clone, PartialEq, ::prost::Oneof)]
724 pub enum DeploymentMethod {
725 #[prost(message, tag = "101")]
726 CloudFormation(CloudFormationTemplate),
727 #[prost(message, tag = "102")]
728 ManagedService(ManagedService),
729 #[prost(message, tag = "103")]
730 HelmChart(HelmChart),
731 #[prost(message, tag = "104")]
732 AzureArmTemplate(AzureArmTemplate),
733 #[prost(message, tag = "105")]
734 Rum(Rum),
735 #[prost(message, tag = "106")]
736 Terraform(Terraform),
737 }
738}
739#[derive(serde::Serialize, serde::Deserialize)]
740#[serde(rename_all = "snake_case")]
741#[derive(Clone, PartialEq, ::prost::Message)]
742pub struct Parameter {
743 #[prost(string, tag = "1")]
744 pub key: ::prost::alloc::string::String,
745 #[prost(oneof = "parameter::Value", tags = "101, 102, 103, 104, 105, 106")]
746 pub value: ::core::option::Option<parameter::Value>,
747}
748pub mod parameter {
750 #[derive(serde::Serialize, serde::Deserialize)]
751 #[serde(rename_all = "snake_case")]
752 #[derive(Clone, PartialEq, ::prost::Message)]
753 pub struct StringList {
754 #[prost(message, repeated, tag = "1")]
755 pub values: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
756 }
757 #[derive(serde::Serialize, serde::Deserialize)]
758 #[serde(rename_all = "snake_case")]
759 #[derive(Clone, PartialEq, ::prost::Message)]
760 pub struct ApiKeyData {
761 #[prost(message, optional, tag = "1")]
762 pub id: ::core::option::Option<::prost::alloc::string::String>,
763 #[prost(message, optional, tag = "2")]
764 pub value: ::core::option::Option<::prost::alloc::string::String>,
765 }
766 #[derive(serde::Serialize, serde::Deserialize)]
767 #[serde(rename_all = "snake_case")]
768 #[derive(Clone, Copy, PartialEq, ::prost::Message)]
769 pub struct SensitiveDataPlaceholder {}
770 #[derive(serde::Serialize, serde::Deserialize)]
771 #[serde(rename_all = "snake_case")]
772 #[derive(Clone, PartialEq, ::prost::Oneof)]
773 pub enum Value {
774 #[prost(message, tag = "101")]
775 StringValue(::prost::alloc::string::String),
776 #[prost(message, tag = "102")]
777 BooleanValue(bool),
778 #[prost(message, tag = "103")]
779 StringList(StringList),
780 #[prost(message, tag = "104")]
781 ApiKey(ApiKeyData),
782 #[prost(message, tag = "105")]
783 NumericValue(f64),
784 #[prost(message, tag = "106")]
785 SensitiveData(SensitiveDataPlaceholder),
786 }
787}
788#[derive(serde::Serialize, serde::Deserialize)]
789#[serde(rename_all = "snake_case")]
790#[derive(Clone, PartialEq, ::prost::Message)]
791pub struct GenericIntegrationParameters {
792 #[prost(message, repeated, tag = "1")]
793 pub parameters: ::prost::alloc::vec::Vec<Parameter>,
794}
795#[derive(serde::Serialize, serde::Deserialize)]
796#[serde(rename_all = "snake_case")]
797#[derive(Clone, PartialEq, ::prost::Message)]
798pub struct IntegrationMetadata {
799 #[prost(message, optional, tag = "4")]
800 pub integration_key: ::core::option::Option<::prost::alloc::string::String>,
801 #[prost(message, optional, tag = "6")]
802 pub version: ::core::option::Option<::prost::alloc::string::String>,
803 #[prost(oneof = "integration_metadata::SpecificData", tags = "113")]
804 pub specific_data: ::core::option::Option<integration_metadata::SpecificData>,
805}
806pub mod integration_metadata {
808 #[derive(serde::Serialize, serde::Deserialize)]
809 #[serde(rename_all = "snake_case")]
810 #[derive(Clone, PartialEq, ::prost::Oneof)]
811 pub enum SpecificData {
812 #[prost(message, tag = "113")]
813 IntegrationParameters(super::GenericIntegrationParameters),
814 }
815}
816#[derive(serde::Serialize, serde::Deserialize)]
817#[serde(rename_all = "snake_case")]
818#[derive(Clone, PartialEq, ::prost::Message)]
819pub struct TestIntegrationResult {
820 #[prost(oneof = "test_integration_result::Result", tags = "1, 2")]
821 pub result: ::core::option::Option<test_integration_result::Result>,
822}
823pub mod test_integration_result {
825 #[derive(serde::Serialize, serde::Deserialize)]
826 #[serde(rename_all = "snake_case")]
827 #[derive(Clone, Copy, PartialEq, ::prost::Message)]
828 pub struct Success {}
829 #[derive(serde::Serialize, serde::Deserialize)]
830 #[serde(rename_all = "snake_case")]
831 #[derive(Clone, PartialEq, ::prost::Message)]
832 pub struct Failure {
833 #[prost(message, optional, tag = "1")]
834 pub error_message: ::core::option::Option<::prost::alloc::string::String>,
835 }
836 #[derive(serde::Serialize, serde::Deserialize)]
837 #[serde(rename_all = "snake_case")]
838 #[derive(Clone, PartialEq, ::prost::Oneof)]
839 pub enum Result {
840 #[prost(message, tag = "1")]
841 Success(Success),
842 #[prost(message, tag = "2")]
843 Failure(Failure),
844 }
845}
846#[derive(serde::Serialize, serde::Deserialize)]
847#[serde(rename_all = "snake_case")]
848#[derive(Clone, PartialEq, ::prost::Message)]
849pub struct RumVersionData {
850 #[prost(message, repeated, tag = "1")]
851 pub versions: ::prost::alloc::vec::Vec<rum_version_data::Version>,
852 #[prost(message, optional, tag = "2")]
853 pub synced_at: ::core::option::Option<::prost_wkt_types::Timestamp>,
854}
855pub mod rum_version_data {
857 #[derive(serde::Serialize, serde::Deserialize)]
858 #[serde(rename_all = "snake_case")]
859 #[derive(Clone, Copy, PartialEq, ::prost::Message)]
860 pub struct SourceMapMetadata {
861 #[prost(message, optional, tag = "1")]
862 pub created_at: ::core::option::Option<::prost_wkt_types::Timestamp>,
863 #[prost(message, optional, tag = "2")]
864 pub is_uploaded_successful: ::core::option::Option<bool>,
865 }
866 #[derive(serde::Serialize, serde::Deserialize)]
867 #[serde(rename_all = "snake_case")]
868 #[derive(Clone, Copy, PartialEq, ::prost::Message)]
869 pub struct LogMetadata {
870 #[prost(message, optional, tag = "1")]
871 pub first_occurrence: ::core::option::Option<::prost_wkt_types::Timestamp>,
872 #[prost(message, optional, tag = "2")]
873 pub last_occurrence: ::core::option::Option<::prost_wkt_types::Timestamp>,
874 }
875 #[derive(serde::Serialize, serde::Deserialize)]
876 #[serde(rename_all = "snake_case")]
877 #[derive(Clone, PartialEq, ::prost::Message)]
878 pub struct Version {
879 #[prost(message, optional, tag = "1")]
880 pub version: ::core::option::Option<::prost::alloc::string::String>,
881 #[prost(message, optional, tag = "2")]
882 pub log_metadata: ::core::option::Option<LogMetadata>,
883 #[prost(message, optional, tag = "3")]
884 pub source_map_metadata: ::core::option::Option<SourceMapMetadata>,
885 }
886}
887#[derive(serde::Serialize, serde::Deserialize)]
888#[serde(rename_all = "snake_case")]
889#[derive(Clone, PartialEq, ::prost::Message)]
890pub struct DeployedIntegrationInformation {
891 #[prost(message, optional, tag = "1")]
892 pub id: ::core::option::Option<::prost::alloc::string::String>,
893 #[prost(message, optional, tag = "2")]
894 pub definition_key: ::core::option::Option<::prost::alloc::string::String>,
895 #[prost(message, optional, tag = "3")]
896 pub definition_version: ::core::option::Option<::prost::alloc::string::String>,
897 #[prost(message, repeated, tag = "4")]
898 pub parameters: ::prost::alloc::vec::Vec<Parameter>,
899 #[prost(message, optional, tag = "5")]
900 pub integration_status: ::core::option::Option<IntegrationStatus>,
901}
902#[derive(serde::Serialize, serde::Deserialize)]
903#[serde(rename_all = "snake_case")]
904#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
905#[repr(i32)]
906pub enum ConnectionStatus {
907 Pending = 0,
908 Active = 1,
909 Failing = 2,
910 StatusUnknown = 3,
911}
912impl ConnectionStatus {
913 pub fn as_str_name(&self) -> &'static str {
918 match self {
919 Self::Pending => "PENDING",
920 Self::Active => "ACTIVE",
921 Self::Failing => "FAILING",
922 Self::StatusUnknown => "STATUS_UNKNOWN",
923 }
924 }
925 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
927 match value {
928 "PENDING" => Some(Self::Pending),
929 "ACTIVE" => Some(Self::Active),
930 "FAILING" => Some(Self::Failing),
931 "STATUS_UNKNOWN" => Some(Self::StatusUnknown),
932 _ => None,
933 }
934 }
935}
936#[derive(serde::Serialize, serde::Deserialize)]
937#[serde(rename_all = "snake_case")]
938#[derive(Clone, Copy, PartialEq, ::prost::Message)]
939pub struct ListManagedIntegrationKeysRequest {}
940#[derive(serde::Serialize, serde::Deserialize)]
941#[serde(rename_all = "snake_case")]
942#[derive(Clone, PartialEq, ::prost::Message)]
943pub struct ListManagedIntegrationKeysResponse {
944 #[prost(message, repeated, tag = "1")]
945 pub integration_keys: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
946}
947#[derive(serde::Serialize, serde::Deserialize)]
948#[serde(rename_all = "snake_case")]
949#[derive(Clone, PartialEq, ::prost::Message)]
950pub struct GetDeployedIntegrationRequest {
951 #[prost(message, optional, tag = "1")]
952 pub integration_id: ::core::option::Option<::prost::alloc::string::String>,
953}
954#[derive(serde::Serialize, serde::Deserialize)]
955#[serde(rename_all = "snake_case")]
956#[derive(Clone, PartialEq, ::prost::Message)]
957pub struct GetDeployedIntegrationResponse {
958 #[prost(message, optional, tag = "1")]
959 pub integration: ::core::option::Option<DeployedIntegrationInformation>,
960}
961#[derive(serde::Serialize, serde::Deserialize)]
962#[serde(rename_all = "snake_case")]
963#[derive(Clone, PartialEq, ::prost::Message)]
964pub struct UpdateIntegrationRequest {
965 #[prost(message, optional, tag = "1")]
967 pub id: ::core::option::Option<::prost::alloc::string::String>,
968 #[prost(message, optional, tag = "2")]
969 pub metadata: ::core::option::Option<IntegrationMetadata>,
970}
971#[derive(serde::Serialize, serde::Deserialize)]
972#[serde(rename_all = "snake_case")]
973#[derive(Clone, Copy, PartialEq, ::prost::Message)]
974pub struct UpdateIntegrationResponse {}
975#[derive(serde::Serialize, serde::Deserialize)]
976#[serde(rename_all = "snake_case")]
977#[derive(Clone, PartialEq, ::prost::Message)]
978pub struct GetIntegrationDefinitionRequest {
979 #[prost(message, optional, tag = "1")]
980 pub id: ::core::option::Option<::prost::alloc::string::String>,
981 #[prost(message, optional, tag = "2")]
982 pub include_testing_revision: ::core::option::Option<bool>,
983}
984#[derive(serde::Serialize, serde::Deserialize)]
985#[serde(rename_all = "snake_case")]
986#[derive(Clone, PartialEq, ::prost::Message)]
987pub struct GetIntegrationDefinitionResponse {
988 #[prost(message, optional, tag = "1")]
989 pub integration_definition: ::core::option::Option<IntegrationDefinition>,
990}
991#[derive(serde::Serialize, serde::Deserialize)]
992#[serde(rename_all = "snake_case")]
993#[derive(Clone, Copy, PartialEq, ::prost::Message)]
994pub struct GetIntegrationsRequest {
995 #[prost(message, optional, tag = "1")]
996 pub include_testing_revision: ::core::option::Option<bool>,
997}
998#[derive(serde::Serialize, serde::Deserialize)]
999#[serde(rename_all = "snake_case")]
1000#[derive(Clone, PartialEq, ::prost::Message)]
1001pub struct GetIntegrationsResponse {
1002 #[prost(message, repeated, tag = "1")]
1003 pub integrations: ::prost::alloc::vec::Vec<
1004 get_integrations_response::IntegrationWithCounts,
1005 >,
1006}
1007pub mod get_integrations_response {
1009 #[derive(serde::Serialize, serde::Deserialize)]
1010 #[serde(rename_all = "snake_case")]
1011 #[derive(Clone, PartialEq, ::prost::Message)]
1012 pub struct IntegrationWithCounts {
1013 #[prost(message, optional, tag = "1")]
1014 pub integration: ::core::option::Option<super::Integration>,
1015 #[prost(message, optional, tag = "2")]
1016 pub amount_integrations: ::core::option::Option<u32>,
1017 #[prost(message, repeated, tag = "3")]
1018 pub errors: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1019 #[prost(message, optional, tag = "4")]
1020 pub upgrade_available: ::core::option::Option<bool>,
1021 #[prost(message, optional, tag = "5")]
1022 pub is_new: ::core::option::Option<bool>,
1023 }
1024}
1025#[derive(serde::Serialize, serde::Deserialize)]
1026#[serde(rename_all = "snake_case")]
1027#[derive(Clone, PartialEq, ::prost::Message)]
1028pub struct GetIntegrationDetailsRequest {
1029 #[prost(message, optional, tag = "1")]
1030 pub id: ::core::option::Option<::prost::alloc::string::String>,
1031 #[prost(message, optional, tag = "2")]
1032 pub include_testing_revision: ::core::option::Option<bool>,
1033}
1034#[derive(serde::Serialize, serde::Deserialize)]
1035#[serde(rename_all = "snake_case")]
1036#[derive(Clone, PartialEq, ::prost::Message)]
1037pub struct GetIntegrationDetailsResponse {
1038 #[prost(message, optional, tag = "1")]
1039 pub integration_detail: ::core::option::Option<IntegrationDetails>,
1040}
1041#[derive(serde::Serialize, serde::Deserialize)]
1042#[serde(rename_all = "snake_case")]
1043#[derive(Clone, PartialEq, ::prost::Message)]
1044pub struct GetManagedIntegrationStatusRequest {
1045 #[prost(string, tag = "1")]
1046 pub integration_id: ::prost::alloc::string::String,
1047}
1048#[derive(serde::Serialize, serde::Deserialize)]
1049#[serde(rename_all = "snake_case")]
1050#[derive(Clone, PartialEq, ::prost::Message)]
1051pub struct GetManagedIntegrationStatusResponse {
1052 #[prost(string, tag = "1")]
1053 pub integration_id: ::prost::alloc::string::String,
1054 #[prost(message, optional, tag = "3")]
1055 pub status: ::core::option::Option<IntegrationStatus>,
1056}
1057#[derive(serde::Serialize, serde::Deserialize)]
1058#[serde(rename_all = "snake_case")]
1059#[derive(Clone, PartialEq, ::prost::Message)]
1060pub struct SaveIntegrationRequest {
1061 #[prost(message, optional, tag = "1")]
1062 pub metadata: ::core::option::Option<IntegrationMetadata>,
1063}
1064#[derive(serde::Serialize, serde::Deserialize)]
1065#[serde(rename_all = "snake_case")]
1066#[derive(Clone, PartialEq, ::prost::Message)]
1067pub struct SaveIntegrationResponse {
1068 #[prost(message, optional, tag = "1")]
1069 pub integration_id: ::core::option::Option<::prost::alloc::string::String>,
1070}
1071#[derive(serde::Serialize, serde::Deserialize)]
1072#[serde(rename_all = "snake_case")]
1073#[derive(Clone, PartialEq, ::prost::Message)]
1074pub struct DeleteIntegrationRequest {
1075 #[prost(message, optional, tag = "1")]
1076 pub integration_id: ::core::option::Option<::prost::alloc::string::String>,
1077}
1078#[derive(serde::Serialize, serde::Deserialize)]
1079#[serde(rename_all = "snake_case")]
1080#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1081pub struct DeleteIntegrationResponse {}
1082#[derive(serde::Serialize, serde::Deserialize)]
1083#[serde(rename_all = "snake_case")]
1084#[derive(Clone, PartialEq, ::prost::Message)]
1085pub struct GetTemplateRequest {
1086 #[prost(message, optional, tag = "1")]
1087 pub integration_id: ::core::option::Option<::prost::alloc::string::String>,
1088 #[prost(oneof = "get_template_request::ExtraParams", tags = "101, 102")]
1089 pub extra_params: ::core::option::Option<get_template_request::ExtraParams>,
1090}
1091pub mod get_template_request {
1093 #[derive(serde::Serialize, serde::Deserialize)]
1094 #[serde(rename_all = "snake_case")]
1095 #[derive(Clone, PartialEq, ::prost::Message)]
1096 pub struct CommonArmParams {
1097 #[prost(message, optional, tag = "1")]
1098 pub logs_url: ::core::option::Option<::prost::alloc::string::String>,
1099 #[prost(message, optional, tag = "2")]
1100 pub api_key: ::core::option::Option<::prost::alloc::string::String>,
1101 #[prost(message, optional, tag = "3")]
1102 pub cgx_domain: ::core::option::Option<::prost::alloc::string::String>,
1103 }
1104 #[derive(serde::Serialize, serde::Deserialize)]
1105 #[serde(rename_all = "snake_case")]
1106 #[derive(Clone, Copy, PartialEq, ::prost::Message)]
1107 pub struct Empty {}
1108 #[derive(serde::Serialize, serde::Deserialize)]
1109 #[serde(rename_all = "snake_case")]
1110 #[derive(Clone, PartialEq, ::prost::Oneof)]
1111 pub enum ExtraParams {
1112 #[prost(message, tag = "101")]
1113 CommonArmParams(CommonArmParams),
1114 #[prost(message, tag = "102")]
1115 Empty(Empty),
1116 }
1117}
1118#[derive(serde::Serialize, serde::Deserialize)]
1119#[serde(rename_all = "snake_case")]
1120#[derive(Clone, PartialEq, ::prost::Message)]
1121pub struct GetTemplateResponse {
1122 #[prost(message, optional, tag = "1")]
1123 pub template_url: ::core::option::Option<::prost::alloc::string::String>,
1124}
1125#[derive(serde::Serialize, serde::Deserialize)]
1126#[serde(rename_all = "snake_case")]
1127#[derive(Clone, PartialEq, ::prost::Message)]
1128pub struct GetRumApplicationVersionDataRequest {
1129 #[prost(message, optional, tag = "1")]
1130 pub application_name: ::core::option::Option<::prost::alloc::string::String>,
1131}
1132#[derive(serde::Serialize, serde::Deserialize)]
1133#[serde(rename_all = "snake_case")]
1134#[derive(Clone, PartialEq, ::prost::Message)]
1135pub struct GetRumApplicationVersionDataResponse {
1136 #[prost(message, optional, tag = "1")]
1137 pub version_data: ::core::option::Option<RumVersionData>,
1138}
1139#[derive(serde::Serialize, serde::Deserialize)]
1140#[serde(rename_all = "snake_case")]
1141#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1142pub struct SyncRumDataRequest {
1143 #[prost(message, optional, tag = "1")]
1145 pub force: ::core::option::Option<bool>,
1146}
1147#[derive(serde::Serialize, serde::Deserialize)]
1148#[serde(rename_all = "snake_case")]
1149#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1150pub struct SyncRumDataResponse {
1151 #[prost(message, optional, tag = "1")]
1152 pub sync_executed: ::core::option::Option<bool>,
1153 #[prost(message, optional, tag = "2")]
1154 pub synced_at: ::core::option::Option<::prost_wkt_types::Timestamp>,
1155}
1156#[derive(serde::Serialize, serde::Deserialize)]
1157#[serde(rename_all = "snake_case")]
1158#[derive(Clone, PartialEq, ::prost::Message)]
1159pub struct TestIntegrationRequest {
1160 #[prost(message, optional, tag = "1")]
1161 pub integration_data: ::core::option::Option<IntegrationMetadata>,
1162 #[prost(message, optional, tag = "2")]
1163 pub integration_id: ::core::option::Option<::prost::alloc::string::String>,
1164}
1165#[derive(serde::Serialize, serde::Deserialize)]
1166#[serde(rename_all = "snake_case")]
1167#[derive(Clone, PartialEq, ::prost::Message)]
1168pub struct TestIntegrationResponse {
1169 #[prost(message, optional, tag = "1")]
1170 pub result: ::core::option::Option<TestIntegrationResult>,
1171}
1172pub mod integration_service_client {
1174 #![allow(
1175 unused_variables,
1176 dead_code,
1177 missing_docs,
1178 clippy::wildcard_imports,
1179 clippy::let_unit_value,
1180 )]
1181 use tonic::codegen::*;
1182 use tonic::codegen::http::Uri;
1183 #[derive(Debug, Clone)]
1184 pub struct IntegrationServiceClient<T> {
1185 inner: tonic::client::Grpc<T>,
1186 }
1187 impl IntegrationServiceClient<tonic::transport::Channel> {
1188 pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
1190 where
1191 D: TryInto<tonic::transport::Endpoint>,
1192 D::Error: Into<StdError>,
1193 {
1194 let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
1195 Ok(Self::new(conn))
1196 }
1197 }
1198 impl<T> IntegrationServiceClient<T>
1199 where
1200 T: tonic::client::GrpcService<tonic::body::BoxBody>,
1201 T::Error: Into<StdError>,
1202 T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
1203 <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
1204 {
1205 pub fn new(inner: T) -> Self {
1206 let inner = tonic::client::Grpc::new(inner);
1207 Self { inner }
1208 }
1209 pub fn with_origin(inner: T, origin: Uri) -> Self {
1210 let inner = tonic::client::Grpc::with_origin(inner, origin);
1211 Self { inner }
1212 }
1213 pub fn with_interceptor<F>(
1214 inner: T,
1215 interceptor: F,
1216 ) -> IntegrationServiceClient<InterceptedService<T, F>>
1217 where
1218 F: tonic::service::Interceptor,
1219 T::ResponseBody: Default,
1220 T: tonic::codegen::Service<
1221 http::Request<tonic::body::BoxBody>,
1222 Response = http::Response<
1223 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
1224 >,
1225 >,
1226 <T as tonic::codegen::Service<
1227 http::Request<tonic::body::BoxBody>,
1228 >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
1229 {
1230 IntegrationServiceClient::new(InterceptedService::new(inner, interceptor))
1231 }
1232 #[must_use]
1237 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
1238 self.inner = self.inner.send_compressed(encoding);
1239 self
1240 }
1241 #[must_use]
1243 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
1244 self.inner = self.inner.accept_compressed(encoding);
1245 self
1246 }
1247 #[must_use]
1251 pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
1252 self.inner = self.inner.max_decoding_message_size(limit);
1253 self
1254 }
1255 #[must_use]
1259 pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
1260 self.inner = self.inner.max_encoding_message_size(limit);
1261 self
1262 }
1263 pub async fn list_managed_integration_keys(
1264 &mut self,
1265 request: impl tonic::IntoRequest<super::ListManagedIntegrationKeysRequest>,
1266 ) -> std::result::Result<
1267 tonic::Response<super::ListManagedIntegrationKeysResponse>,
1268 tonic::Status,
1269 > {
1270 self.inner
1271 .ready()
1272 .await
1273 .map_err(|e| {
1274 tonic::Status::unknown(
1275 format!("Service was not ready: {}", e.into()),
1276 )
1277 })?;
1278 let codec = tonic::codec::ProstCodec::default();
1279 let path = http::uri::PathAndQuery::from_static(
1280 "/com.coralogix.integrations.v1.IntegrationService/ListManagedIntegrationKeys",
1281 );
1282 let mut req = request.into_request();
1283 req.extensions_mut()
1284 .insert(
1285 GrpcMethod::new(
1286 "com.coralogix.integrations.v1.IntegrationService",
1287 "ListManagedIntegrationKeys",
1288 ),
1289 );
1290 self.inner.unary(req, path, codec).await
1291 }
1292 pub async fn get_deployed_integration(
1293 &mut self,
1294 request: impl tonic::IntoRequest<super::GetDeployedIntegrationRequest>,
1295 ) -> std::result::Result<
1296 tonic::Response<super::GetDeployedIntegrationResponse>,
1297 tonic::Status,
1298 > {
1299 self.inner
1300 .ready()
1301 .await
1302 .map_err(|e| {
1303 tonic::Status::unknown(
1304 format!("Service was not ready: {}", e.into()),
1305 )
1306 })?;
1307 let codec = tonic::codec::ProstCodec::default();
1308 let path = http::uri::PathAndQuery::from_static(
1309 "/com.coralogix.integrations.v1.IntegrationService/GetDeployedIntegration",
1310 );
1311 let mut req = request.into_request();
1312 req.extensions_mut()
1313 .insert(
1314 GrpcMethod::new(
1315 "com.coralogix.integrations.v1.IntegrationService",
1316 "GetDeployedIntegration",
1317 ),
1318 );
1319 self.inner.unary(req, path, codec).await
1320 }
1321 pub async fn get_integrations(
1322 &mut self,
1323 request: impl tonic::IntoRequest<super::GetIntegrationsRequest>,
1324 ) -> std::result::Result<
1325 tonic::Response<super::GetIntegrationsResponse>,
1326 tonic::Status,
1327 > {
1328 self.inner
1329 .ready()
1330 .await
1331 .map_err(|e| {
1332 tonic::Status::unknown(
1333 format!("Service was not ready: {}", e.into()),
1334 )
1335 })?;
1336 let codec = tonic::codec::ProstCodec::default();
1337 let path = http::uri::PathAndQuery::from_static(
1338 "/com.coralogix.integrations.v1.IntegrationService/GetIntegrations",
1339 );
1340 let mut req = request.into_request();
1341 req.extensions_mut()
1342 .insert(
1343 GrpcMethod::new(
1344 "com.coralogix.integrations.v1.IntegrationService",
1345 "GetIntegrations",
1346 ),
1347 );
1348 self.inner.unary(req, path, codec).await
1349 }
1350 pub async fn get_integration_definition(
1351 &mut self,
1352 request: impl tonic::IntoRequest<super::GetIntegrationDefinitionRequest>,
1353 ) -> std::result::Result<
1354 tonic::Response<super::GetIntegrationDefinitionResponse>,
1355 tonic::Status,
1356 > {
1357 self.inner
1358 .ready()
1359 .await
1360 .map_err(|e| {
1361 tonic::Status::unknown(
1362 format!("Service was not ready: {}", e.into()),
1363 )
1364 })?;
1365 let codec = tonic::codec::ProstCodec::default();
1366 let path = http::uri::PathAndQuery::from_static(
1367 "/com.coralogix.integrations.v1.IntegrationService/GetIntegrationDefinition",
1368 );
1369 let mut req = request.into_request();
1370 req.extensions_mut()
1371 .insert(
1372 GrpcMethod::new(
1373 "com.coralogix.integrations.v1.IntegrationService",
1374 "GetIntegrationDefinition",
1375 ),
1376 );
1377 self.inner.unary(req, path, codec).await
1378 }
1379 pub async fn get_integration_details(
1380 &mut self,
1381 request: impl tonic::IntoRequest<super::GetIntegrationDetailsRequest>,
1382 ) -> std::result::Result<
1383 tonic::Response<super::GetIntegrationDetailsResponse>,
1384 tonic::Status,
1385 > {
1386 self.inner
1387 .ready()
1388 .await
1389 .map_err(|e| {
1390 tonic::Status::unknown(
1391 format!("Service was not ready: {}", e.into()),
1392 )
1393 })?;
1394 let codec = tonic::codec::ProstCodec::default();
1395 let path = http::uri::PathAndQuery::from_static(
1396 "/com.coralogix.integrations.v1.IntegrationService/GetIntegrationDetails",
1397 );
1398 let mut req = request.into_request();
1399 req.extensions_mut()
1400 .insert(
1401 GrpcMethod::new(
1402 "com.coralogix.integrations.v1.IntegrationService",
1403 "GetIntegrationDetails",
1404 ),
1405 );
1406 self.inner.unary(req, path, codec).await
1407 }
1408 pub async fn get_managed_integration_status(
1409 &mut self,
1410 request: impl tonic::IntoRequest<super::GetManagedIntegrationStatusRequest>,
1411 ) -> std::result::Result<
1412 tonic::Response<super::GetManagedIntegrationStatusResponse>,
1413 tonic::Status,
1414 > {
1415 self.inner
1416 .ready()
1417 .await
1418 .map_err(|e| {
1419 tonic::Status::unknown(
1420 format!("Service was not ready: {}", e.into()),
1421 )
1422 })?;
1423 let codec = tonic::codec::ProstCodec::default();
1424 let path = http::uri::PathAndQuery::from_static(
1425 "/com.coralogix.integrations.v1.IntegrationService/GetManagedIntegrationStatus",
1426 );
1427 let mut req = request.into_request();
1428 req.extensions_mut()
1429 .insert(
1430 GrpcMethod::new(
1431 "com.coralogix.integrations.v1.IntegrationService",
1432 "GetManagedIntegrationStatus",
1433 ),
1434 );
1435 self.inner.unary(req, path, codec).await
1436 }
1437 pub async fn save_integration(
1438 &mut self,
1439 request: impl tonic::IntoRequest<super::SaveIntegrationRequest>,
1440 ) -> std::result::Result<
1441 tonic::Response<super::SaveIntegrationResponse>,
1442 tonic::Status,
1443 > {
1444 self.inner
1445 .ready()
1446 .await
1447 .map_err(|e| {
1448 tonic::Status::unknown(
1449 format!("Service was not ready: {}", e.into()),
1450 )
1451 })?;
1452 let codec = tonic::codec::ProstCodec::default();
1453 let path = http::uri::PathAndQuery::from_static(
1454 "/com.coralogix.integrations.v1.IntegrationService/SaveIntegration",
1455 );
1456 let mut req = request.into_request();
1457 req.extensions_mut()
1458 .insert(
1459 GrpcMethod::new(
1460 "com.coralogix.integrations.v1.IntegrationService",
1461 "SaveIntegration",
1462 ),
1463 );
1464 self.inner.unary(req, path, codec).await
1465 }
1466 pub async fn update_integration(
1467 &mut self,
1468 request: impl tonic::IntoRequest<super::UpdateIntegrationRequest>,
1469 ) -> std::result::Result<
1470 tonic::Response<super::UpdateIntegrationResponse>,
1471 tonic::Status,
1472 > {
1473 self.inner
1474 .ready()
1475 .await
1476 .map_err(|e| {
1477 tonic::Status::unknown(
1478 format!("Service was not ready: {}", e.into()),
1479 )
1480 })?;
1481 let codec = tonic::codec::ProstCodec::default();
1482 let path = http::uri::PathAndQuery::from_static(
1483 "/com.coralogix.integrations.v1.IntegrationService/UpdateIntegration",
1484 );
1485 let mut req = request.into_request();
1486 req.extensions_mut()
1487 .insert(
1488 GrpcMethod::new(
1489 "com.coralogix.integrations.v1.IntegrationService",
1490 "UpdateIntegration",
1491 ),
1492 );
1493 self.inner.unary(req, path, codec).await
1494 }
1495 pub async fn delete_integration(
1496 &mut self,
1497 request: impl tonic::IntoRequest<super::DeleteIntegrationRequest>,
1498 ) -> std::result::Result<
1499 tonic::Response<super::DeleteIntegrationResponse>,
1500 tonic::Status,
1501 > {
1502 self.inner
1503 .ready()
1504 .await
1505 .map_err(|e| {
1506 tonic::Status::unknown(
1507 format!("Service was not ready: {}", e.into()),
1508 )
1509 })?;
1510 let codec = tonic::codec::ProstCodec::default();
1511 let path = http::uri::PathAndQuery::from_static(
1512 "/com.coralogix.integrations.v1.IntegrationService/DeleteIntegration",
1513 );
1514 let mut req = request.into_request();
1515 req.extensions_mut()
1516 .insert(
1517 GrpcMethod::new(
1518 "com.coralogix.integrations.v1.IntegrationService",
1519 "DeleteIntegration",
1520 ),
1521 );
1522 self.inner.unary(req, path, codec).await
1523 }
1524 pub async fn get_template(
1525 &mut self,
1526 request: impl tonic::IntoRequest<super::GetTemplateRequest>,
1527 ) -> std::result::Result<
1528 tonic::Response<super::GetTemplateResponse>,
1529 tonic::Status,
1530 > {
1531 self.inner
1532 .ready()
1533 .await
1534 .map_err(|e| {
1535 tonic::Status::unknown(
1536 format!("Service was not ready: {}", e.into()),
1537 )
1538 })?;
1539 let codec = tonic::codec::ProstCodec::default();
1540 let path = http::uri::PathAndQuery::from_static(
1541 "/com.coralogix.integrations.v1.IntegrationService/GetTemplate",
1542 );
1543 let mut req = request.into_request();
1544 req.extensions_mut()
1545 .insert(
1546 GrpcMethod::new(
1547 "com.coralogix.integrations.v1.IntegrationService",
1548 "GetTemplate",
1549 ),
1550 );
1551 self.inner.unary(req, path, codec).await
1552 }
1553 pub async fn get_rum_application_version_data(
1554 &mut self,
1555 request: impl tonic::IntoRequest<super::GetRumApplicationVersionDataRequest>,
1556 ) -> std::result::Result<
1557 tonic::Response<super::GetRumApplicationVersionDataResponse>,
1558 tonic::Status,
1559 > {
1560 self.inner
1561 .ready()
1562 .await
1563 .map_err(|e| {
1564 tonic::Status::unknown(
1565 format!("Service was not ready: {}", e.into()),
1566 )
1567 })?;
1568 let codec = tonic::codec::ProstCodec::default();
1569 let path = http::uri::PathAndQuery::from_static(
1570 "/com.coralogix.integrations.v1.IntegrationService/GetRumApplicationVersionData",
1571 );
1572 let mut req = request.into_request();
1573 req.extensions_mut()
1574 .insert(
1575 GrpcMethod::new(
1576 "com.coralogix.integrations.v1.IntegrationService",
1577 "GetRumApplicationVersionData",
1578 ),
1579 );
1580 self.inner.unary(req, path, codec).await
1581 }
1582 pub async fn sync_rum_data(
1583 &mut self,
1584 request: impl tonic::IntoRequest<super::SyncRumDataRequest>,
1585 ) -> std::result::Result<
1586 tonic::Response<super::SyncRumDataResponse>,
1587 tonic::Status,
1588 > {
1589 self.inner
1590 .ready()
1591 .await
1592 .map_err(|e| {
1593 tonic::Status::unknown(
1594 format!("Service was not ready: {}", e.into()),
1595 )
1596 })?;
1597 let codec = tonic::codec::ProstCodec::default();
1598 let path = http::uri::PathAndQuery::from_static(
1599 "/com.coralogix.integrations.v1.IntegrationService/SyncRumData",
1600 );
1601 let mut req = request.into_request();
1602 req.extensions_mut()
1603 .insert(
1604 GrpcMethod::new(
1605 "com.coralogix.integrations.v1.IntegrationService",
1606 "SyncRumData",
1607 ),
1608 );
1609 self.inner.unary(req, path, codec).await
1610 }
1611 pub async fn test_integration(
1612 &mut self,
1613 request: impl tonic::IntoRequest<super::TestIntegrationRequest>,
1614 ) -> std::result::Result<
1615 tonic::Response<super::TestIntegrationResponse>,
1616 tonic::Status,
1617 > {
1618 self.inner
1619 .ready()
1620 .await
1621 .map_err(|e| {
1622 tonic::Status::unknown(
1623 format!("Service was not ready: {}", e.into()),
1624 )
1625 })?;
1626 let codec = tonic::codec::ProstCodec::default();
1627 let path = http::uri::PathAndQuery::from_static(
1628 "/com.coralogix.integrations.v1.IntegrationService/TestIntegration",
1629 );
1630 let mut req = request.into_request();
1631 req.extensions_mut()
1632 .insert(
1633 GrpcMethod::new(
1634 "com.coralogix.integrations.v1.IntegrationService",
1635 "TestIntegration",
1636 ),
1637 );
1638 self.inner.unary(req, path, codec).await
1639 }
1640 }
1641}
1642#[derive(serde::Serialize, serde::Deserialize)]
1643#[serde(rename_all = "snake_case")]
1644#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1645pub struct GetContextualDataIntegrationsRequest {
1646 #[prost(message, optional, tag = "1")]
1647 pub include_testing_integrations: ::core::option::Option<bool>,
1648}
1649#[derive(serde::Serialize, serde::Deserialize)]
1650#[serde(rename_all = "snake_case")]
1651#[derive(Clone, PartialEq, ::prost::Message)]
1652pub struct GetContextualDataIntegrationsResponse {
1653 #[prost(message, repeated, tag = "1")]
1654 pub integrations: ::prost::alloc::vec::Vec<
1655 get_contextual_data_integrations_response::IntegrationWithCounts,
1656 >,
1657}
1658pub mod get_contextual_data_integrations_response {
1660 #[derive(serde::Serialize, serde::Deserialize)]
1661 #[serde(rename_all = "snake_case")]
1662 #[derive(Clone, PartialEq, ::prost::Message)]
1663 pub struct IntegrationWithCounts {
1664 #[prost(message, optional, tag = "1")]
1665 pub integration: ::core::option::Option<super::Integration>,
1666 #[prost(message, optional, tag = "2")]
1667 pub amount_integrations: ::core::option::Option<u32>,
1668 #[prost(message, repeated, tag = "3")]
1669 pub errors: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1670 #[prost(message, optional, tag = "4")]
1671 pub upgrade_available: ::core::option::Option<bool>,
1672 #[prost(message, optional, tag = "5")]
1673 pub is_new: ::core::option::Option<bool>,
1674 }
1675}
1676#[derive(serde::Serialize, serde::Deserialize)]
1677#[serde(rename_all = "snake_case")]
1678#[derive(Clone, PartialEq, ::prost::Message)]
1679pub struct GetContextualDataIntegrationDefinitionRequest {
1680 #[prost(message, optional, tag = "1")]
1681 pub id: ::core::option::Option<::prost::alloc::string::String>,
1682 #[prost(message, optional, tag = "2")]
1683 pub include_testing_integrations: ::core::option::Option<bool>,
1684}
1685#[derive(serde::Serialize, serde::Deserialize)]
1686#[serde(rename_all = "snake_case")]
1687#[derive(Clone, PartialEq, ::prost::Message)]
1688pub struct GetContextualDataIntegrationDefinitionResponse {
1689 #[prost(message, optional, tag = "1")]
1690 pub integration_definition: ::core::option::Option<IntegrationDefinition>,
1691}
1692#[derive(serde::Serialize, serde::Deserialize)]
1693#[serde(rename_all = "snake_case")]
1694#[derive(Clone, PartialEq, ::prost::Message)]
1695pub struct GetContextualDataIntegrationDetailsRequest {
1696 #[prost(message, optional, tag = "1")]
1697 pub id: ::core::option::Option<::prost::alloc::string::String>,
1698 #[prost(message, optional, tag = "2")]
1699 pub include_testing_revisions: ::core::option::Option<bool>,
1700}
1701#[derive(serde::Serialize, serde::Deserialize)]
1702#[serde(rename_all = "snake_case")]
1703#[derive(Clone, PartialEq, ::prost::Message)]
1704pub struct GetContextualDataIntegrationDetailsResponse {
1705 #[prost(message, optional, tag = "1")]
1706 pub integration_detail: ::core::option::Option<IntegrationDetails>,
1707}
1708#[derive(serde::Serialize, serde::Deserialize)]
1709#[serde(rename_all = "snake_case")]
1710#[derive(Clone, PartialEq, ::prost::Message)]
1711pub struct UpdateContextualDataIntegrationRequest {
1712 #[prost(message, optional, tag = "1")]
1713 pub integration_id: ::core::option::Option<::prost::alloc::string::String>,
1714 #[prost(message, optional, tag = "2")]
1715 pub metadata: ::core::option::Option<IntegrationMetadata>,
1716}
1717#[derive(serde::Serialize, serde::Deserialize)]
1718#[serde(rename_all = "snake_case")]
1719#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1720pub struct UpdateContextualDataIntegrationResponse {}
1721#[derive(serde::Serialize, serde::Deserialize)]
1722#[serde(rename_all = "snake_case")]
1723#[derive(Clone, PartialEq, ::prost::Message)]
1724pub struct TestContextualDataIntegrationRequest {
1725 #[prost(message, optional, tag = "1")]
1726 pub integration_data: ::core::option::Option<IntegrationMetadata>,
1727 #[prost(message, optional, tag = "2")]
1728 pub integration_id: ::core::option::Option<::prost::alloc::string::String>,
1729}
1730#[derive(serde::Serialize, serde::Deserialize)]
1731#[serde(rename_all = "snake_case")]
1732#[derive(Clone, PartialEq, ::prost::Message)]
1733pub struct TestContextualDataIntegrationResponse {
1734 #[prost(message, optional, tag = "1")]
1735 pub result: ::core::option::Option<TestIntegrationResult>,
1736}
1737#[derive(serde::Serialize, serde::Deserialize)]
1738#[serde(rename_all = "snake_case")]
1739#[derive(Clone, PartialEq, ::prost::Message)]
1740pub struct SaveContextualDataIntegrationRequest {
1741 #[prost(message, optional, tag = "1")]
1742 pub metadata: ::core::option::Option<IntegrationMetadata>,
1743}
1744#[derive(serde::Serialize, serde::Deserialize)]
1745#[serde(rename_all = "snake_case")]
1746#[derive(Clone, PartialEq, ::prost::Message)]
1747pub struct SaveContextualDataIntegrationResponse {
1748 #[prost(message, optional, tag = "1")]
1749 pub integration_id: ::core::option::Option<::prost::alloc::string::String>,
1750}
1751#[derive(serde::Serialize, serde::Deserialize)]
1752#[serde(rename_all = "snake_case")]
1753#[derive(Clone, PartialEq, ::prost::Message)]
1754pub struct DeleteContextualDataIntegrationRequest {
1755 #[prost(message, optional, tag = "1")]
1756 pub integration_id: ::core::option::Option<::prost::alloc::string::String>,
1757}
1758#[derive(serde::Serialize, serde::Deserialize)]
1759#[serde(rename_all = "snake_case")]
1760#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1761pub struct DeleteContextualDataIntegrationResponse {}
1762pub mod contextual_data_integration_service_client {
1764 #![allow(
1765 unused_variables,
1766 dead_code,
1767 missing_docs,
1768 clippy::wildcard_imports,
1769 clippy::let_unit_value,
1770 )]
1771 use tonic::codegen::*;
1772 use tonic::codegen::http::Uri;
1773 #[derive(Debug, Clone)]
1774 pub struct ContextualDataIntegrationServiceClient<T> {
1775 inner: tonic::client::Grpc<T>,
1776 }
1777 impl ContextualDataIntegrationServiceClient<tonic::transport::Channel> {
1778 pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
1780 where
1781 D: TryInto<tonic::transport::Endpoint>,
1782 D::Error: Into<StdError>,
1783 {
1784 let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
1785 Ok(Self::new(conn))
1786 }
1787 }
1788 impl<T> ContextualDataIntegrationServiceClient<T>
1789 where
1790 T: tonic::client::GrpcService<tonic::body::BoxBody>,
1791 T::Error: Into<StdError>,
1792 T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
1793 <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
1794 {
1795 pub fn new(inner: T) -> Self {
1796 let inner = tonic::client::Grpc::new(inner);
1797 Self { inner }
1798 }
1799 pub fn with_origin(inner: T, origin: Uri) -> Self {
1800 let inner = tonic::client::Grpc::with_origin(inner, origin);
1801 Self { inner }
1802 }
1803 pub fn with_interceptor<F>(
1804 inner: T,
1805 interceptor: F,
1806 ) -> ContextualDataIntegrationServiceClient<InterceptedService<T, F>>
1807 where
1808 F: tonic::service::Interceptor,
1809 T::ResponseBody: Default,
1810 T: tonic::codegen::Service<
1811 http::Request<tonic::body::BoxBody>,
1812 Response = http::Response<
1813 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
1814 >,
1815 >,
1816 <T as tonic::codegen::Service<
1817 http::Request<tonic::body::BoxBody>,
1818 >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
1819 {
1820 ContextualDataIntegrationServiceClient::new(
1821 InterceptedService::new(inner, interceptor),
1822 )
1823 }
1824 #[must_use]
1829 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
1830 self.inner = self.inner.send_compressed(encoding);
1831 self
1832 }
1833 #[must_use]
1835 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
1836 self.inner = self.inner.accept_compressed(encoding);
1837 self
1838 }
1839 #[must_use]
1843 pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
1844 self.inner = self.inner.max_decoding_message_size(limit);
1845 self
1846 }
1847 #[must_use]
1851 pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
1852 self.inner = self.inner.max_encoding_message_size(limit);
1853 self
1854 }
1855 pub async fn get_contextual_data_integrations(
1856 &mut self,
1857 request: impl tonic::IntoRequest<super::GetContextualDataIntegrationsRequest>,
1858 ) -> std::result::Result<
1859 tonic::Response<super::GetContextualDataIntegrationsResponse>,
1860 tonic::Status,
1861 > {
1862 self.inner
1863 .ready()
1864 .await
1865 .map_err(|e| {
1866 tonic::Status::unknown(
1867 format!("Service was not ready: {}", e.into()),
1868 )
1869 })?;
1870 let codec = tonic::codec::ProstCodec::default();
1871 let path = http::uri::PathAndQuery::from_static(
1872 "/com.coralogix.integrations.v1.ContextualDataIntegrationService/GetContextualDataIntegrations",
1873 );
1874 let mut req = request.into_request();
1875 req.extensions_mut()
1876 .insert(
1877 GrpcMethod::new(
1878 "com.coralogix.integrations.v1.ContextualDataIntegrationService",
1879 "GetContextualDataIntegrations",
1880 ),
1881 );
1882 self.inner.unary(req, path, codec).await
1883 }
1884 pub async fn get_contextual_data_integration_definition(
1885 &mut self,
1886 request: impl tonic::IntoRequest<
1887 super::GetContextualDataIntegrationDefinitionRequest,
1888 >,
1889 ) -> std::result::Result<
1890 tonic::Response<super::GetContextualDataIntegrationDefinitionResponse>,
1891 tonic::Status,
1892 > {
1893 self.inner
1894 .ready()
1895 .await
1896 .map_err(|e| {
1897 tonic::Status::unknown(
1898 format!("Service was not ready: {}", e.into()),
1899 )
1900 })?;
1901 let codec = tonic::codec::ProstCodec::default();
1902 let path = http::uri::PathAndQuery::from_static(
1903 "/com.coralogix.integrations.v1.ContextualDataIntegrationService/GetContextualDataIntegrationDefinition",
1904 );
1905 let mut req = request.into_request();
1906 req.extensions_mut()
1907 .insert(
1908 GrpcMethod::new(
1909 "com.coralogix.integrations.v1.ContextualDataIntegrationService",
1910 "GetContextualDataIntegrationDefinition",
1911 ),
1912 );
1913 self.inner.unary(req, path, codec).await
1914 }
1915 pub async fn get_contextual_data_integration_details(
1916 &mut self,
1917 request: impl tonic::IntoRequest<
1918 super::GetContextualDataIntegrationDetailsRequest,
1919 >,
1920 ) -> std::result::Result<
1921 tonic::Response<super::GetContextualDataIntegrationDetailsResponse>,
1922 tonic::Status,
1923 > {
1924 self.inner
1925 .ready()
1926 .await
1927 .map_err(|e| {
1928 tonic::Status::unknown(
1929 format!("Service was not ready: {}", e.into()),
1930 )
1931 })?;
1932 let codec = tonic::codec::ProstCodec::default();
1933 let path = http::uri::PathAndQuery::from_static(
1934 "/com.coralogix.integrations.v1.ContextualDataIntegrationService/GetContextualDataIntegrationDetails",
1935 );
1936 let mut req = request.into_request();
1937 req.extensions_mut()
1938 .insert(
1939 GrpcMethod::new(
1940 "com.coralogix.integrations.v1.ContextualDataIntegrationService",
1941 "GetContextualDataIntegrationDetails",
1942 ),
1943 );
1944 self.inner.unary(req, path, codec).await
1945 }
1946 pub async fn test_contextual_data_integration(
1947 &mut self,
1948 request: impl tonic::IntoRequest<super::TestContextualDataIntegrationRequest>,
1949 ) -> std::result::Result<
1950 tonic::Response<super::TestContextualDataIntegrationResponse>,
1951 tonic::Status,
1952 > {
1953 self.inner
1954 .ready()
1955 .await
1956 .map_err(|e| {
1957 tonic::Status::unknown(
1958 format!("Service was not ready: {}", e.into()),
1959 )
1960 })?;
1961 let codec = tonic::codec::ProstCodec::default();
1962 let path = http::uri::PathAndQuery::from_static(
1963 "/com.coralogix.integrations.v1.ContextualDataIntegrationService/TestContextualDataIntegration",
1964 );
1965 let mut req = request.into_request();
1966 req.extensions_mut()
1967 .insert(
1968 GrpcMethod::new(
1969 "com.coralogix.integrations.v1.ContextualDataIntegrationService",
1970 "TestContextualDataIntegration",
1971 ),
1972 );
1973 self.inner.unary(req, path, codec).await
1974 }
1975 pub async fn save_contextual_data_integration(
1976 &mut self,
1977 request: impl tonic::IntoRequest<super::SaveContextualDataIntegrationRequest>,
1978 ) -> std::result::Result<
1979 tonic::Response<super::SaveContextualDataIntegrationResponse>,
1980 tonic::Status,
1981 > {
1982 self.inner
1983 .ready()
1984 .await
1985 .map_err(|e| {
1986 tonic::Status::unknown(
1987 format!("Service was not ready: {}", e.into()),
1988 )
1989 })?;
1990 let codec = tonic::codec::ProstCodec::default();
1991 let path = http::uri::PathAndQuery::from_static(
1992 "/com.coralogix.integrations.v1.ContextualDataIntegrationService/SaveContextualDataIntegration",
1993 );
1994 let mut req = request.into_request();
1995 req.extensions_mut()
1996 .insert(
1997 GrpcMethod::new(
1998 "com.coralogix.integrations.v1.ContextualDataIntegrationService",
1999 "SaveContextualDataIntegration",
2000 ),
2001 );
2002 self.inner.unary(req, path, codec).await
2003 }
2004 pub async fn update_contextual_data_integration(
2005 &mut self,
2006 request: impl tonic::IntoRequest<
2007 super::UpdateContextualDataIntegrationRequest,
2008 >,
2009 ) -> std::result::Result<
2010 tonic::Response<super::UpdateContextualDataIntegrationResponse>,
2011 tonic::Status,
2012 > {
2013 self.inner
2014 .ready()
2015 .await
2016 .map_err(|e| {
2017 tonic::Status::unknown(
2018 format!("Service was not ready: {}", e.into()),
2019 )
2020 })?;
2021 let codec = tonic::codec::ProstCodec::default();
2022 let path = http::uri::PathAndQuery::from_static(
2023 "/com.coralogix.integrations.v1.ContextualDataIntegrationService/UpdateContextualDataIntegration",
2024 );
2025 let mut req = request.into_request();
2026 req.extensions_mut()
2027 .insert(
2028 GrpcMethod::new(
2029 "com.coralogix.integrations.v1.ContextualDataIntegrationService",
2030 "UpdateContextualDataIntegration",
2031 ),
2032 );
2033 self.inner.unary(req, path, codec).await
2034 }
2035 pub async fn delete_contextual_data_integration(
2036 &mut self,
2037 request: impl tonic::IntoRequest<
2038 super::DeleteContextualDataIntegrationRequest,
2039 >,
2040 ) -> std::result::Result<
2041 tonic::Response<super::DeleteContextualDataIntegrationResponse>,
2042 tonic::Status,
2043 > {
2044 self.inner
2045 .ready()
2046 .await
2047 .map_err(|e| {
2048 tonic::Status::unknown(
2049 format!("Service was not ready: {}", e.into()),
2050 )
2051 })?;
2052 let codec = tonic::codec::ProstCodec::default();
2053 let path = http::uri::PathAndQuery::from_static(
2054 "/com.coralogix.integrations.v1.ContextualDataIntegrationService/DeleteContextualDataIntegration",
2055 );
2056 let mut req = request.into_request();
2057 req.extensions_mut()
2058 .insert(
2059 GrpcMethod::new(
2060 "com.coralogix.integrations.v1.ContextualDataIntegrationService",
2061 "DeleteContextualDataIntegration",
2062 ),
2063 );
2064 self.inner.unary(req, path, codec).await
2065 }
2066 }
2067}