cx_api/generated/

com.coralogix.integrations.v1.rs

// This file is @generated by prost-build.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CloudFormationStack {
    #[prost(message, optional, tag = "1")]
    pub arn: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "2")]
    pub region: ::core::option::Option<::prost::alloc::string::String>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ArmStack {
    #[prost(message, optional, tag = "1")]
    pub subscription_id: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "2")]
    pub resource_group_name: ::core::option::Option<::prost::alloc::string::String>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct NoDeployment {}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct IntegrationStatus {
    #[prost(enumeration = "ConnectionStatus", tag = "1")]
    pub connection_status: i32,
    #[prost(map = "string, string", tag = "3")]
    pub details: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    #[prost(message, repeated, tag = "4")]
    pub messages: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct IntegrationDoc {
    #[prost(message, optional, tag = "1")]
    pub name: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "2")]
    pub link: ::core::option::Option<::prost::alloc::string::String>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct IntegrationType {
    #[prost(oneof = "integration_type::IntegrationType", tags = "1, 2, 3, 4, 5, 6, 7")]
    pub integration_type: ::core::option::Option<integration_type::IntegrationType>,
}
/// Nested message and enum types in `IntegrationType`.
pub mod integration_type {
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct Managed {
        #[prost(enumeration = "managed::Variant", tag = "2")]
        pub variant: i32,
    }
    /// Nested message and enum types in `Managed`.
    pub mod managed {
        #[derive(serde::Serialize, serde::Deserialize)]
        #[serde(rename_all = "snake_case")]
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum Variant {
            Default = 0,
            Gcp = 1,
            Oauth = 2,
            Custom = 3,
        }
        impl Variant {
            /// String value of the enum field names used in the ProtoBuf definition.
            ///
            /// The values are not transformed in any way and thus are considered stable
            /// (if the ProtoBuf definition does not change) and safe for programmatic use.
            pub fn as_str_name(&self) -> &'static str {
                match self {
                    Self::Default => "DEFAULT",
                    Self::Gcp => "GCP",
                    Self::Oauth => "OAUTH",
                    Self::Custom => "CUSTOM",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "DEFAULT" => Some(Self::Default),
                    "GCP" => Some(Self::Gcp),
                    "OAUTH" => Some(Self::Oauth),
                    "CUSTOM" => Some(Self::Custom),
                    _ => None,
                }
            }
        }
    }
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct Untracked {}
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct Cloudformation {}
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct AzureArm {}
    /// Handling this as a separate type because it's managed only by extensions-api.
    /// At some point, as soon as it's moved to integrations-service,
    /// it's expected to be merged under contextual data integrations.
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct PushBasedContextualData {}
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct ContextualData {}
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct GenericWebhook {}
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
    pub enum IntegrationType {
        #[prost(message, tag = "1")]
        Managed(Managed),
        #[prost(message, tag = "2")]
        Untracked(Untracked),
        #[prost(message, tag = "3")]
        Cloudformation(Cloudformation),
        #[prost(message, tag = "4")]
        Arm(AzureArm),
        #[prost(message, tag = "5")]
        PushBasedContextualData(PushBasedContextualData),
        #[prost(message, tag = "6")]
        ContextualData(ContextualData),
        #[prost(message, tag = "7")]
        GenericWebhook(GenericWebhook),
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Integration {
    /// short_name in the integrations.integration_definitions
    #[prost(message, optional, tag = "1")]
    pub id: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "2")]
    pub name: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "3")]
    pub description: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "4")]
    pub icon: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "5")]
    pub dark_icon: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, repeated, tag = "7")]
    pub tags: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(message, repeated, tag = "8")]
    pub versions: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "9")]
    pub integration_type: ::core::option::Option<IntegrationType>,
    #[prost(message, optional, tag = "10")]
    pub feature_flag: ::core::option::Option<::prost::alloc::string::String>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RevisionRef {
    /// integration revision version
    #[prost(string, tag = "1")]
    pub version: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub description_md: ::prost::alloc::string::String,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LocalChangelog {
    #[prost(message, repeated, tag = "1")]
    pub changes: ::prost::alloc::vec::Vec<RevisionRef>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExternalUrl {
    #[prost(string, tag = "1")]
    pub url: ::prost::alloc::string::String,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct IntegrationDetails {
    #[prost(message, optional, tag = "1")]
    pub integration: ::core::option::Option<Integration>,
    #[prost(message, repeated, tag = "3")]
    pub extensions: ::prost::alloc::vec::Vec<super::super::extensions::v1::Extension>,
    #[prost(message, repeated, tag = "4")]
    pub docs: ::prost::alloc::vec::Vec<IntegrationDoc>,
    #[prost(oneof = "integration_details::IntegrationTypeDetails", tags = "500")]
    pub integration_type_details: ::core::option::Option<
        integration_details::IntegrationTypeDetails,
    >,
    #[prost(oneof = "integration_details::Changelog", tags = "201, 202")]
    pub changelog: ::core::option::Option<integration_details::Changelog>,
}
/// Nested message and enum types in `IntegrationDetails`.
pub mod integration_details {
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct DefaultIntegrationDetails {
        #[prost(message, repeated, tag = "1")]
        pub registered: ::prost::alloc::vec::Vec<
            default_integration_details::RegisteredInstance,
        >,
    }
    /// Nested message and enum types in `DefaultIntegrationDetails`.
    pub mod default_integration_details {
        #[derive(serde::Serialize, serde::Deserialize)]
        #[serde(rename_all = "snake_case")]
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct RegisteredInstance {
            #[prost(message, optional, tag = "1")]
            pub id: ::core::option::Option<::prost::alloc::string::String>,
            #[prost(message, optional, tag = "2")]
            pub definition_version: ::core::option::Option<
                ::prost::alloc::string::String,
            >,
            #[prost(message, optional, tag = "3")]
            pub last_updated: ::core::option::Option<::prost_wkt_types::Timestamp>,
            #[prost(message, repeated, tag = "4")]
            pub parameters: ::prost::alloc::vec::Vec<super::super::Parameter>,
            #[prost(message, optional, tag = "7")]
            pub integration_status: ::core::option::Option<
                super::super::IntegrationStatus,
            >,
            #[prost(message, optional, tag = "8")]
            pub is_testing: ::core::option::Option<bool>,
            #[prost(oneof = "registered_instance::Deployment", tags = "100, 101, 102")]
            pub deployment: ::core::option::Option<registered_instance::Deployment>,
        }
        /// Nested message and enum types in `RegisteredInstance`.
        pub mod registered_instance {
            #[derive(serde::Serialize, serde::Deserialize)]
            #[serde(rename_all = "snake_case")]
            #[derive(Clone, PartialEq, ::prost::Oneof)]
            pub enum Deployment {
                #[prost(message, tag = "100")]
                Empty(super::super::super::NoDeployment),
                #[prost(message, tag = "101")]
                Cloudformation(super::super::super::CloudFormationStack),
                #[prost(message, tag = "102")]
                Arm(super::super::super::ArmStack),
            }
        }
    }
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum IntegrationTypeDetails {
        #[prost(message, tag = "500")]
        Default(DefaultIntegrationDetails),
    }
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Changelog {
        #[prost(message, tag = "201")]
        Local(super::LocalChangelog),
        #[prost(message, tag = "202")]
        External(super::ExternalUrl),
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct IntegrationDefinition {
    /// short_name in the integrations.integration_definitions
    #[prost(message, optional, tag = "1")]
    pub key: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "2")]
    pub integration_type: ::core::option::Option<IntegrationType>,
    #[prost(message, repeated, tag = "3")]
    pub revisions: ::prost::alloc::vec::Vec<IntegrationRevision>,
    #[prost(message, optional, tag = "4")]
    pub feature_flag: ::core::option::Option<::prost::alloc::string::String>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct IntegrationRevision {
    /// version from the integrations.integration_definitions_revision
    #[prost(message, optional, tag = "1")]
    pub id: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, repeated, tag = "3")]
    pub fields: ::prost::alloc::vec::Vec<integration_revision::FieldInformation>,
    #[prost(message, repeated, tag = "4")]
    pub groups: ::prost::alloc::vec::Vec<integration_revision::Group>,
    #[prost(string, optional, tag = "5")]
    pub upgrade_instructions_md: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(bool, tag = "6")]
    pub revision_deployment_supported: bool,
    #[prost(message, optional, tag = "7")]
    pub feature_flag: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(
        oneof = "integration_revision::DeploymentMethod",
        tags = "101, 102, 103, 104, 105, 106"
    )]
    pub deployment_method: ::core::option::Option<
        integration_revision::DeploymentMethod,
    >,
}
/// Nested message and enum types in `IntegrationRevision`.
pub mod integration_revision {
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct CloudFormationTemplate {
        #[prost(message, optional, tag = "1")]
        pub template_url: ::core::option::Option<::prost::alloc::string::String>,
        #[prost(map = "string, string", tag = "2")]
        pub parameters: ::std::collections::HashMap<
            ::prost::alloc::string::String,
            ::prost::alloc::string::String,
        >,
        #[prost(map = "string, string", tag = "3")]
        pub post_installation_steps: ::std::collections::HashMap<
            ::prost::alloc::string::String,
            ::prost::alloc::string::String,
        >,
    }
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct ManagedService {}
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct HelmChart {
        #[prost(message, optional, tag = "1")]
        pub template: ::core::option::Option<::prost::alloc::string::String>,
        #[prost(message, repeated, tag = "2")]
        pub commands: ::prost::alloc::vec::Vec<CommandInformation>,
        #[prost(message, optional, tag = "3")]
        pub guide: ::core::option::Option<IntegrationGuide>,
    }
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Terraform {
        #[prost(message, repeated, tag = "1")]
        pub configuration_blocks: ::prost::alloc::vec::Vec<ConfigurationBlock>,
    }
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Rum {
        #[prost(message, repeated, tag = "1")]
        pub browser_sdk_commands: ::prost::alloc::vec::Vec<CommandInformation>,
        #[prost(message, repeated, tag = "2")]
        pub source_map_commands: ::prost::alloc::vec::Vec<CommandInformation>,
    }
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct AzureArmTemplate {
        #[prost(message, optional, tag = "1")]
        pub template_url: ::core::option::Option<::prost::alloc::string::String>,
    }
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ListTextValue {
        #[prost(message, repeated, tag = "2")]
        pub options: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
        #[prost(message, repeated, tag = "4")]
        pub default_values: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    }
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct SingleValue {
        #[prost(message, optional, tag = "1")]
        pub default_value: ::core::option::Option<::prost::alloc::string::String>,
    }
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct SingleBooleanValue {
        #[prost(message, optional, tag = "1")]
        pub default_value: ::core::option::Option<bool>,
    }
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct SingleNumericValue {
        #[prost(message, optional, tag = "1")]
        pub default_value: ::core::option::Option<f64>,
    }
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MultipleSelectionValue {
        #[prost(message, repeated, tag = "1")]
        pub options: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    }
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct SelectionValue {
        #[prost(message, repeated, tag = "1")]
        pub options: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
        #[prost(message, optional, tag = "2")]
        pub default_value: ::core::option::Option<::prost::alloc::string::String>,
    }
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct FieldCondition {
        #[prost(enumeration = "field_condition::ConditionType", tag = "1")]
        pub r#type: i32,
        #[prost(message, repeated, tag = "2")]
        pub values: ::prost::alloc::vec::Vec<field_condition::FieldValue>,
    }
    /// Nested message and enum types in `FieldCondition`.
    pub mod field_condition {
        #[derive(serde::Serialize, serde::Deserialize)]
        #[serde(rename_all = "snake_case")]
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct FieldValue {
            #[prost(string, tag = "1")]
            pub field_name: ::prost::alloc::string::String,
            #[prost(string, tag = "2")]
            pub value_pattern: ::prost::alloc::string::String,
        }
        #[derive(serde::Serialize, serde::Deserialize)]
        #[serde(rename_all = "snake_case")]
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum ConditionType {
            Unknown = 0,
            Or = 1,
            And = 2,
        }
        impl ConditionType {
            /// String value of the enum field names used in the ProtoBuf definition.
            ///
            /// The values are not transformed in any way and thus are considered stable
            /// (if the ProtoBuf definition does not change) and safe for programmatic use.
            pub fn as_str_name(&self) -> &'static str {
                match self {
                    Self::Unknown => "UNKNOWN",
                    Self::Or => "OR",
                    Self::And => "AND",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "UNKNOWN" => Some(Self::Unknown),
                    "OR" => Some(Self::Or),
                    "AND" => Some(Self::And),
                    _ => None,
                }
            }
        }
    }
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Group {
        #[prost(message, optional, tag = "1")]
        pub id: ::core::option::Option<::prost::alloc::string::String>,
        #[prost(message, optional, tag = "2")]
        pub name: ::core::option::Option<::prost::alloc::string::String>,
    }
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct FieldInformation {
        #[prost(enumeration = "InputType", tag = "1")]
        pub r#type: i32,
        #[prost(message, optional, tag = "2")]
        pub name: ::core::option::Option<::prost::alloc::string::String>,
        #[prost(message, optional, tag = "3")]
        pub tooltip: ::core::option::Option<::prost::alloc::string::String>,
        #[prost(message, optional, tag = "4")]
        pub template_param_name: ::core::option::Option<::prost::alloc::string::String>,
        #[prost(message, optional, tag = "5")]
        pub placeholder: ::core::option::Option<::prost::alloc::string::String>,
        #[prost(message, optional, tag = "6")]
        pub required: ::core::option::Option<bool>,
        #[prost(message, optional, tag = "7")]
        pub predefined: ::core::option::Option<bool>,
        #[prost(message, optional, tag = "8")]
        pub visible: ::core::option::Option<bool>,
        #[prost(message, optional, tag = "9")]
        pub readonly: ::core::option::Option<bool>,
        #[prost(message, optional, tag = "10")]
        pub applicable_if: ::core::option::Option<FieldCondition>,
        #[prost(message, optional, tag = "11")]
        pub group_id: ::core::option::Option<::prost::alloc::string::String>,
        #[prost(message, optional, tag = "12")]
        pub upgrade_notice: ::core::option::Option<::prost::alloc::string::String>,
        #[prost(message, optional, tag = "13")]
        pub allowed_pattern: ::core::option::Option<::prost::alloc::string::String>,
        #[prost(message, optional, tag = "14")]
        pub documentation_reference: ::core::option::Option<
            ::prost::alloc::string::String,
        >,
        #[prost(
            oneof = "field_information::Value",
            tags = "101, 102, 103, 104, 105, 106"
        )]
        pub value: ::core::option::Option<field_information::Value>,
    }
    /// Nested message and enum types in `FieldInformation`.
    pub mod field_information {
        #[derive(serde::Serialize, serde::Deserialize)]
        #[serde(rename_all = "snake_case")]
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum Value {
            #[prost(message, tag = "101")]
            Single(super::SingleValue),
            #[prost(message, tag = "102")]
            MultiText(super::ListTextValue),
            #[prost(message, tag = "103")]
            MultipleSelection(super::MultipleSelectionValue),
            #[prost(message, tag = "104")]
            SingleBoolean(super::SingleBooleanValue),
            #[prost(message, tag = "105")]
            Selection(super::SelectionValue),
            #[prost(message, tag = "106")]
            SingleNumber(super::SingleNumericValue),
        }
    }
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct CommandInformation {
        #[prost(message, optional, tag = "1")]
        pub name: ::core::option::Option<::prost::alloc::string::String>,
        #[prost(message, optional, tag = "2")]
        pub command: ::core::option::Option<::prost::alloc::string::String>,
        #[prost(message, optional, tag = "3")]
        pub description: ::core::option::Option<::prost::alloc::string::String>,
        #[prost(message, optional, tag = "4")]
        pub tooltip_text: ::core::option::Option<::prost::alloc::string::String>,
        #[prost(enumeration = "command_information::Language", optional, tag = "5")]
        pub language: ::core::option::Option<i32>,
        #[prost(message, repeated, tag = "6")]
        pub links: ::prost::alloc::vec::Vec<command_information::Link>,
    }
    /// Nested message and enum types in `CommandInformation`.
    pub mod command_information {
        #[derive(serde::Serialize, serde::Deserialize)]
        #[serde(rename_all = "snake_case")]
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct Link {
            #[prost(string, tag = "1")]
            pub key: ::prost::alloc::string::String,
            #[prost(string, tag = "2")]
            pub text: ::prost::alloc::string::String,
            #[prost(string, tag = "3")]
            pub url: ::prost::alloc::string::String,
        }
        #[derive(serde::Serialize, serde::Deserialize)]
        #[serde(rename_all = "snake_case")]
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum Language {
            Unknown = 0,
            Bash = 1,
            Javascript = 2,
        }
        impl Language {
            /// String value of the enum field names used in the ProtoBuf definition.
            ///
            /// The values are not transformed in any way and thus are considered stable
            /// (if the ProtoBuf definition does not change) and safe for programmatic use.
            pub fn as_str_name(&self) -> &'static str {
                match self {
                    Self::Unknown => "UNKNOWN",
                    Self::Bash => "BASH",
                    Self::Javascript => "JAVASCRIPT",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "UNKNOWN" => Some(Self::Unknown),
                    "BASH" => Some(Self::Bash),
                    "JAVASCRIPT" => Some(Self::Javascript),
                    _ => None,
                }
            }
        }
    }
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ConfigurationBlock {
        #[prost(message, optional, tag = "1")]
        pub name: ::core::option::Option<::prost::alloc::string::String>,
        #[prost(message, optional, tag = "2")]
        pub value: ::core::option::Option<::prost::alloc::string::String>,
        #[prost(message, optional, tag = "3")]
        pub description: ::core::option::Option<::prost::alloc::string::String>,
    }
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct IntegrationGuide {
        #[prost(message, optional, tag = "1")]
        pub introduction: ::core::option::Option<::prost::alloc::string::String>,
        #[prost(message, optional, tag = "2")]
        pub installation_requirements: ::core::option::Option<
            ::prost::alloc::string::String,
        >,
    }
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum InputType {
        ApiKey = 0,
        Text = 1,
        ListText = 2,
        MultipleSelection = 3,
        Boolean = 4,
        Select = 5,
        Json = 6,
        Number = 7,
        SensitiveData = 8,
        JsonObjectArray = 9,
    }
    impl InputType {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::ApiKey => "API_KEY",
                Self::Text => "TEXT",
                Self::ListText => "LIST_TEXT",
                Self::MultipleSelection => "MULTIPLE_SELECTION",
                Self::Boolean => "BOOLEAN",
                Self::Select => "SELECT",
                Self::Json => "JSON",
                Self::Number => "NUMBER",
                Self::SensitiveData => "SENSITIVE_DATA",
                Self::JsonObjectArray => "JSON_OBJECT_ARRAY",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "API_KEY" => Some(Self::ApiKey),
                "TEXT" => Some(Self::Text),
                "LIST_TEXT" => Some(Self::ListText),
                "MULTIPLE_SELECTION" => Some(Self::MultipleSelection),
                "BOOLEAN" => Some(Self::Boolean),
                "SELECT" => Some(Self::Select),
                "JSON" => Some(Self::Json),
                "NUMBER" => Some(Self::Number),
                "SENSITIVE_DATA" => Some(Self::SensitiveData),
                "JSON_OBJECT_ARRAY" => Some(Self::JsonObjectArray),
                _ => None,
            }
        }
    }
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum DeploymentMethod {
        #[prost(message, tag = "101")]
        CloudFormation(CloudFormationTemplate),
        #[prost(message, tag = "102")]
        ManagedService(ManagedService),
        #[prost(message, tag = "103")]
        HelmChart(HelmChart),
        #[prost(message, tag = "104")]
        AzureArmTemplate(AzureArmTemplate),
        #[prost(message, tag = "105")]
        Rum(Rum),
        #[prost(message, tag = "106")]
        Terraform(Terraform),
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Parameter {
    #[prost(string, tag = "1")]
    pub key: ::prost::alloc::string::String,
    #[prost(oneof = "parameter::Value", tags = "101, 102, 103, 104, 105, 106")]
    pub value: ::core::option::Option<parameter::Value>,
}
/// Nested message and enum types in `Parameter`.
pub mod parameter {
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct StringList {
        #[prost(message, repeated, tag = "1")]
        pub values: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    }
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ApiKeyData {
        #[prost(message, optional, tag = "1")]
        pub id: ::core::option::Option<::prost::alloc::string::String>,
        #[prost(message, optional, tag = "2")]
        pub value: ::core::option::Option<::prost::alloc::string::String>,
    }
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct SensitiveDataPlaceholder {}
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Value {
        #[prost(message, tag = "101")]
        StringValue(::prost::alloc::string::String),
        #[prost(message, tag = "102")]
        BooleanValue(bool),
        #[prost(message, tag = "103")]
        StringList(StringList),
        #[prost(message, tag = "104")]
        ApiKey(ApiKeyData),
        #[prost(message, tag = "105")]
        NumericValue(f64),
        #[prost(message, tag = "106")]
        SensitiveData(SensitiveDataPlaceholder),
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GenericIntegrationParameters {
    #[prost(message, repeated, tag = "1")]
    pub parameters: ::prost::alloc::vec::Vec<Parameter>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct IntegrationMetadata {
    #[prost(message, optional, tag = "4")]
    pub integration_key: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "6")]
    pub version: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(oneof = "integration_metadata::SpecificData", tags = "113")]
    pub specific_data: ::core::option::Option<integration_metadata::SpecificData>,
}
/// Nested message and enum types in `IntegrationMetadata`.
pub mod integration_metadata {
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum SpecificData {
        #[prost(message, tag = "113")]
        IntegrationParameters(super::GenericIntegrationParameters),
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TestIntegrationResult {
    #[prost(oneof = "test_integration_result::Result", tags = "1, 2")]
    pub result: ::core::option::Option<test_integration_result::Result>,
}
/// Nested message and enum types in `TestIntegrationResult`.
pub mod test_integration_result {
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct Success {}
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Failure {
        #[prost(message, optional, tag = "1")]
        pub error_message: ::core::option::Option<::prost::alloc::string::String>,
    }
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Result {
        #[prost(message, tag = "1")]
        Success(Success),
        #[prost(message, tag = "2")]
        Failure(Failure),
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RumVersionData {
    #[prost(message, repeated, tag = "1")]
    pub versions: ::prost::alloc::vec::Vec<rum_version_data::Version>,
    #[prost(message, optional, tag = "2")]
    pub synced_at: ::core::option::Option<::prost_wkt_types::Timestamp>,
}
/// Nested message and enum types in `RumVersionData`.
pub mod rum_version_data {
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct SourceMapMetadata {
        #[prost(message, optional, tag = "1")]
        pub created_at: ::core::option::Option<::prost_wkt_types::Timestamp>,
        #[prost(message, optional, tag = "2")]
        pub is_uploaded_successful: ::core::option::Option<bool>,
    }
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct LogMetadata {
        #[prost(message, optional, tag = "1")]
        pub first_occurrence: ::core::option::Option<::prost_wkt_types::Timestamp>,
        #[prost(message, optional, tag = "2")]
        pub last_occurrence: ::core::option::Option<::prost_wkt_types::Timestamp>,
    }
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Version {
        #[prost(message, optional, tag = "1")]
        pub version: ::core::option::Option<::prost::alloc::string::String>,
        #[prost(message, optional, tag = "2")]
        pub log_metadata: ::core::option::Option<LogMetadata>,
        #[prost(message, optional, tag = "3")]
        pub source_map_metadata: ::core::option::Option<SourceMapMetadata>,
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeployedIntegrationInformation {
    #[prost(message, optional, tag = "1")]
    pub id: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "2")]
    pub definition_key: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "3")]
    pub definition_version: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, repeated, tag = "4")]
    pub parameters: ::prost::alloc::vec::Vec<Parameter>,
    #[prost(message, optional, tag = "5")]
    pub integration_status: ::core::option::Option<IntegrationStatus>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ConnectionStatus {
    Pending = 0,
    Active = 1,
    Failing = 2,
    StatusUnknown = 3,
}
impl ConnectionStatus {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Pending => "PENDING",
            Self::Active => "ACTIVE",
            Self::Failing => "FAILING",
            Self::StatusUnknown => "STATUS_UNKNOWN",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "PENDING" => Some(Self::Pending),
            "ACTIVE" => Some(Self::Active),
            "FAILING" => Some(Self::Failing),
            "STATUS_UNKNOWN" => Some(Self::StatusUnknown),
            _ => None,
        }
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ListManagedIntegrationKeysRequest {}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListManagedIntegrationKeysResponse {
    #[prost(message, repeated, tag = "1")]
    pub integration_keys: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetDeployedIntegrationRequest {
    #[prost(message, optional, tag = "1")]
    pub integration_id: ::core::option::Option<::prost::alloc::string::String>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetDeployedIntegrationResponse {
    #[prost(message, optional, tag = "1")]
    pub integration: ::core::option::Option<DeployedIntegrationInformation>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateIntegrationRequest {
    /// This is the integration ID generated at creation time
    #[prost(message, optional, tag = "1")]
    pub id: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "2")]
    pub metadata: ::core::option::Option<IntegrationMetadata>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct UpdateIntegrationResponse {}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetIntegrationDefinitionRequest {
    #[prost(message, optional, tag = "1")]
    pub id: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "2")]
    pub include_testing_revision: ::core::option::Option<bool>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetIntegrationDefinitionResponse {
    #[prost(message, optional, tag = "1")]
    pub integration_definition: ::core::option::Option<IntegrationDefinition>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct GetIntegrationsRequest {
    #[prost(message, optional, tag = "1")]
    pub include_testing_revision: ::core::option::Option<bool>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetIntegrationsResponse {
    #[prost(message, repeated, tag = "1")]
    pub integrations: ::prost::alloc::vec::Vec<
        get_integrations_response::IntegrationWithCounts,
    >,
}
/// Nested message and enum types in `GetIntegrationsResponse`.
pub mod get_integrations_response {
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct IntegrationWithCounts {
        #[prost(message, optional, tag = "1")]
        pub integration: ::core::option::Option<super::Integration>,
        #[prost(message, optional, tag = "2")]
        pub amount_integrations: ::core::option::Option<u32>,
        #[prost(message, repeated, tag = "3")]
        pub errors: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
        #[prost(message, optional, tag = "4")]
        pub upgrade_available: ::core::option::Option<bool>,
        #[prost(message, optional, tag = "5")]
        pub is_new: ::core::option::Option<bool>,
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetIntegrationDetailsRequest {
    #[prost(message, optional, tag = "1")]
    pub id: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "2")]
    pub include_testing_revision: ::core::option::Option<bool>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetIntegrationDetailsResponse {
    #[prost(message, optional, tag = "1")]
    pub integration_detail: ::core::option::Option<IntegrationDetails>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetManagedIntegrationStatusRequest {
    #[prost(string, tag = "1")]
    pub integration_id: ::prost::alloc::string::String,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetManagedIntegrationStatusResponse {
    #[prost(string, tag = "1")]
    pub integration_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "3")]
    pub status: ::core::option::Option<IntegrationStatus>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SaveIntegrationRequest {
    #[prost(message, optional, tag = "1")]
    pub metadata: ::core::option::Option<IntegrationMetadata>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SaveIntegrationResponse {
    #[prost(message, optional, tag = "1")]
    pub integration_id: ::core::option::Option<::prost::alloc::string::String>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteIntegrationRequest {
    #[prost(message, optional, tag = "1")]
    pub integration_id: ::core::option::Option<::prost::alloc::string::String>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct DeleteIntegrationResponse {}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetTemplateRequest {
    #[prost(message, optional, tag = "1")]
    pub integration_id: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(oneof = "get_template_request::ExtraParams", tags = "101, 102")]
    pub extra_params: ::core::option::Option<get_template_request::ExtraParams>,
}
/// Nested message and enum types in `GetTemplateRequest`.
pub mod get_template_request {
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct CommonArmParams {
        #[prost(message, optional, tag = "1")]
        pub logs_url: ::core::option::Option<::prost::alloc::string::String>,
        #[prost(message, optional, tag = "2")]
        pub api_key: ::core::option::Option<::prost::alloc::string::String>,
        #[prost(message, optional, tag = "3")]
        pub cgx_domain: ::core::option::Option<::prost::alloc::string::String>,
    }
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct Empty {}
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum ExtraParams {
        #[prost(message, tag = "101")]
        CommonArmParams(CommonArmParams),
        #[prost(message, tag = "102")]
        Empty(Empty),
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetTemplateResponse {
    #[prost(message, optional, tag = "1")]
    pub template_url: ::core::option::Option<::prost::alloc::string::String>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetRumApplicationVersionDataRequest {
    #[prost(message, optional, tag = "1")]
    pub application_name: ::core::option::Option<::prost::alloc::string::String>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetRumApplicationVersionDataResponse {
    #[prost(message, optional, tag = "1")]
    pub version_data: ::core::option::Option<RumVersionData>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct SyncRumDataRequest {
    /// The time between syncs is controlled by configuration.
    #[prost(message, optional, tag = "1")]
    pub force: ::core::option::Option<bool>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct SyncRumDataResponse {
    #[prost(message, optional, tag = "1")]
    pub sync_executed: ::core::option::Option<bool>,
    #[prost(message, optional, tag = "2")]
    pub synced_at: ::core::option::Option<::prost_wkt_types::Timestamp>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TestIntegrationRequest {
    #[prost(message, optional, tag = "1")]
    pub integration_data: ::core::option::Option<IntegrationMetadata>,
    #[prost(message, optional, tag = "2")]
    pub integration_id: ::core::option::Option<::prost::alloc::string::String>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TestIntegrationResponse {
    #[prost(message, optional, tag = "1")]
    pub result: ::core::option::Option<TestIntegrationResult>,
}
/// Generated client implementations.
pub mod integration_service_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    #[derive(Debug, Clone)]
    pub struct IntegrationServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl IntegrationServiceClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> IntegrationServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> IntegrationServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            IntegrationServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        pub async fn list_managed_integration_keys(
            &mut self,
            request: impl tonic::IntoRequest<super::ListManagedIntegrationKeysRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListManagedIntegrationKeysResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/com.coralogix.integrations.v1.IntegrationService/ListManagedIntegrationKeys",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "com.coralogix.integrations.v1.IntegrationService",
                        "ListManagedIntegrationKeys",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_deployed_integration(
            &mut self,
            request: impl tonic::IntoRequest<super::GetDeployedIntegrationRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetDeployedIntegrationResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/com.coralogix.integrations.v1.IntegrationService/GetDeployedIntegration",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "com.coralogix.integrations.v1.IntegrationService",
                        "GetDeployedIntegration",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_integrations(
            &mut self,
            request: impl tonic::IntoRequest<super::GetIntegrationsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetIntegrationsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/com.coralogix.integrations.v1.IntegrationService/GetIntegrations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "com.coralogix.integrations.v1.IntegrationService",
                        "GetIntegrations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_integration_definition(
            &mut self,
            request: impl tonic::IntoRequest<super::GetIntegrationDefinitionRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetIntegrationDefinitionResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/com.coralogix.integrations.v1.IntegrationService/GetIntegrationDefinition",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "com.coralogix.integrations.v1.IntegrationService",
                        "GetIntegrationDefinition",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_integration_details(
            &mut self,
            request: impl tonic::IntoRequest<super::GetIntegrationDetailsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetIntegrationDetailsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/com.coralogix.integrations.v1.IntegrationService/GetIntegrationDetails",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "com.coralogix.integrations.v1.IntegrationService",
                        "GetIntegrationDetails",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_managed_integration_status(
            &mut self,
            request: impl tonic::IntoRequest<super::GetManagedIntegrationStatusRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetManagedIntegrationStatusResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/com.coralogix.integrations.v1.IntegrationService/GetManagedIntegrationStatus",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "com.coralogix.integrations.v1.IntegrationService",
                        "GetManagedIntegrationStatus",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn save_integration(
            &mut self,
            request: impl tonic::IntoRequest<super::SaveIntegrationRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SaveIntegrationResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/com.coralogix.integrations.v1.IntegrationService/SaveIntegration",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "com.coralogix.integrations.v1.IntegrationService",
                        "SaveIntegration",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn update_integration(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateIntegrationRequest>,
        ) -> std::result::Result<
            tonic::Response<super::UpdateIntegrationResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/com.coralogix.integrations.v1.IntegrationService/UpdateIntegration",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "com.coralogix.integrations.v1.IntegrationService",
                        "UpdateIntegration",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn delete_integration(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteIntegrationRequest>,
        ) -> std::result::Result<
            tonic::Response<super::DeleteIntegrationResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/com.coralogix.integrations.v1.IntegrationService/DeleteIntegration",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "com.coralogix.integrations.v1.IntegrationService",
                        "DeleteIntegration",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_template(
            &mut self,
            request: impl tonic::IntoRequest<super::GetTemplateRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetTemplateResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/com.coralogix.integrations.v1.IntegrationService/GetTemplate",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "com.coralogix.integrations.v1.IntegrationService",
                        "GetTemplate",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_rum_application_version_data(
            &mut self,
            request: impl tonic::IntoRequest<super::GetRumApplicationVersionDataRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetRumApplicationVersionDataResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/com.coralogix.integrations.v1.IntegrationService/GetRumApplicationVersionData",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "com.coralogix.integrations.v1.IntegrationService",
                        "GetRumApplicationVersionData",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn sync_rum_data(
            &mut self,
            request: impl tonic::IntoRequest<super::SyncRumDataRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SyncRumDataResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/com.coralogix.integrations.v1.IntegrationService/SyncRumData",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "com.coralogix.integrations.v1.IntegrationService",
                        "SyncRumData",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn test_integration(
            &mut self,
            request: impl tonic::IntoRequest<super::TestIntegrationRequest>,
        ) -> std::result::Result<
            tonic::Response<super::TestIntegrationResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/com.coralogix.integrations.v1.IntegrationService/TestIntegration",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "com.coralogix.integrations.v1.IntegrationService",
                        "TestIntegration",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct GetContextualDataIntegrationsRequest {
    #[prost(message, optional, tag = "1")]
    pub include_testing_integrations: ::core::option::Option<bool>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetContextualDataIntegrationsResponse {
    #[prost(message, repeated, tag = "1")]
    pub integrations: ::prost::alloc::vec::Vec<
        get_contextual_data_integrations_response::IntegrationWithCounts,
    >,
}
/// Nested message and enum types in `GetContextualDataIntegrationsResponse`.
pub mod get_contextual_data_integrations_response {
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct IntegrationWithCounts {
        #[prost(message, optional, tag = "1")]
        pub integration: ::core::option::Option<super::Integration>,
        #[prost(message, optional, tag = "2")]
        pub amount_integrations: ::core::option::Option<u32>,
        #[prost(message, repeated, tag = "3")]
        pub errors: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
        #[prost(message, optional, tag = "4")]
        pub upgrade_available: ::core::option::Option<bool>,
        #[prost(message, optional, tag = "5")]
        pub is_new: ::core::option::Option<bool>,
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetContextualDataIntegrationDefinitionRequest {
    #[prost(message, optional, tag = "1")]
    pub id: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "2")]
    pub include_testing_integrations: ::core::option::Option<bool>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetContextualDataIntegrationDefinitionResponse {
    #[prost(message, optional, tag = "1")]
    pub integration_definition: ::core::option::Option<IntegrationDefinition>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetContextualDataIntegrationDetailsRequest {
    #[prost(message, optional, tag = "1")]
    pub id: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "2")]
    pub include_testing_revisions: ::core::option::Option<bool>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetContextualDataIntegrationDetailsResponse {
    #[prost(message, optional, tag = "1")]
    pub integration_detail: ::core::option::Option<IntegrationDetails>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateContextualDataIntegrationRequest {
    #[prost(message, optional, tag = "1")]
    pub integration_id: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "2")]
    pub metadata: ::core::option::Option<IntegrationMetadata>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct UpdateContextualDataIntegrationResponse {}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TestContextualDataIntegrationRequest {
    #[prost(message, optional, tag = "1")]
    pub integration_data: ::core::option::Option<IntegrationMetadata>,
    #[prost(message, optional, tag = "2")]
    pub integration_id: ::core::option::Option<::prost::alloc::string::String>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TestContextualDataIntegrationResponse {
    #[prost(message, optional, tag = "1")]
    pub result: ::core::option::Option<TestIntegrationResult>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SaveContextualDataIntegrationRequest {
    #[prost(message, optional, tag = "1")]
    pub metadata: ::core::option::Option<IntegrationMetadata>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SaveContextualDataIntegrationResponse {
    #[prost(message, optional, tag = "1")]
    pub integration_id: ::core::option::Option<::prost::alloc::string::String>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteContextualDataIntegrationRequest {
    #[prost(message, optional, tag = "1")]
    pub integration_id: ::core::option::Option<::prost::alloc::string::String>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct DeleteContextualDataIntegrationResponse {}
/// Generated client implementations.
pub mod contextual_data_integration_service_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    #[derive(Debug, Clone)]
    pub struct ContextualDataIntegrationServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ContextualDataIntegrationServiceClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> ContextualDataIntegrationServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> ContextualDataIntegrationServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            ContextualDataIntegrationServiceClient::new(
                InterceptedService::new(inner, interceptor),
            )
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        pub async fn get_contextual_data_integrations(
            &mut self,
            request: impl tonic::IntoRequest<super::GetContextualDataIntegrationsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetContextualDataIntegrationsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/com.coralogix.integrations.v1.ContextualDataIntegrationService/GetContextualDataIntegrations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "com.coralogix.integrations.v1.ContextualDataIntegrationService",
                        "GetContextualDataIntegrations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_contextual_data_integration_definition(
            &mut self,
            request: impl tonic::IntoRequest<
                super::GetContextualDataIntegrationDefinitionRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::GetContextualDataIntegrationDefinitionResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/com.coralogix.integrations.v1.ContextualDataIntegrationService/GetContextualDataIntegrationDefinition",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "com.coralogix.integrations.v1.ContextualDataIntegrationService",
                        "GetContextualDataIntegrationDefinition",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_contextual_data_integration_details(
            &mut self,
            request: impl tonic::IntoRequest<
                super::GetContextualDataIntegrationDetailsRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::GetContextualDataIntegrationDetailsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/com.coralogix.integrations.v1.ContextualDataIntegrationService/GetContextualDataIntegrationDetails",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "com.coralogix.integrations.v1.ContextualDataIntegrationService",
                        "GetContextualDataIntegrationDetails",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn test_contextual_data_integration(
            &mut self,
            request: impl tonic::IntoRequest<super::TestContextualDataIntegrationRequest>,
        ) -> std::result::Result<
            tonic::Response<super::TestContextualDataIntegrationResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/com.coralogix.integrations.v1.ContextualDataIntegrationService/TestContextualDataIntegration",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "com.coralogix.integrations.v1.ContextualDataIntegrationService",
                        "TestContextualDataIntegration",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn save_contextual_data_integration(
            &mut self,
            request: impl tonic::IntoRequest<super::SaveContextualDataIntegrationRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SaveContextualDataIntegrationResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/com.coralogix.integrations.v1.ContextualDataIntegrationService/SaveContextualDataIntegration",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "com.coralogix.integrations.v1.ContextualDataIntegrationService",
                        "SaveContextualDataIntegration",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn update_contextual_data_integration(
            &mut self,
            request: impl tonic::IntoRequest<
                super::UpdateContextualDataIntegrationRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::UpdateContextualDataIntegrationResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/com.coralogix.integrations.v1.ContextualDataIntegrationService/UpdateContextualDataIntegration",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "com.coralogix.integrations.v1.ContextualDataIntegrationService",
                        "UpdateContextualDataIntegration",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn delete_contextual_data_integration(
            &mut self,
            request: impl tonic::IntoRequest<
                super::DeleteContextualDataIntegrationRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::DeleteContextualDataIntegrationResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/com.coralogix.integrations.v1.ContextualDataIntegrationService/DeleteContextualDataIntegration",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "com.coralogix.integrations.v1.ContextualDataIntegrationService",
                        "DeleteContextualDataIntegration",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}