cx_api/generated/

com.coralogix.enrichment.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 EnrichmentType {
    #[prost(oneof = "enrichment_type::Type", tags = "1, 2, 3, 4")]
    pub r#type: ::core::option::Option<enrichment_type::Type>,
}
/// Nested message and enum types in `EnrichmentType`.
pub mod enrichment_type {
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Type {
        #[prost(message, tag = "1")]
        GeoIp(super::GeoIpType),
        #[prost(message, tag = "2")]
        SuspiciousIp(super::SuspiciousIpType),
        #[prost(message, tag = "3")]
        Aws(super::AwsType),
        #[prost(message, tag = "4")]
        CustomEnrichment(super::CustomEnrichmentType),
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct GeoIpType {
    #[prost(bool, optional, tag = "4")]
    pub with_asn: ::core::option::Option<bool>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct SuspiciousIpType {}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AwsType {
    #[prost(message, optional, tag = "1")]
    pub resource_type: ::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 CustomEnrichmentType {
    #[prost(message, optional, tag = "1")]
    pub id: ::core::option::Option<u32>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Enrichment {
    #[prost(uint32, tag = "1")]
    pub id: u32,
    #[prost(string, tag = "2")]
    pub field_name: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "3")]
    pub enrichment_type: ::core::option::Option<EnrichmentType>,
    #[prost(message, optional, tag = "4")]
    pub enriched_field_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 EnrichmentRequestModel {
    #[prost(message, optional, tag = "1")]
    pub field_name: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "2")]
    pub enrichment_type: ::core::option::Option<EnrichmentType>,
    #[prost(message, optional, tag = "3")]
    pub enriched_field_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 EnrichmentFieldDefinition {
    /// the field name of the key targeted for enrichment
    #[prost(message, optional, tag = "1")]
    pub field_name: ::core::option::Option<::prost::alloc::string::String>,
    /// the field of the enriched key after enrichment
    #[prost(message, optional, tag = "3")]
    pub enriched_field_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 CompanyEnrichmentSettings {
    #[prost(uint32, tag = "1")]
    pub enrichment_amount_limit: u32,
    #[prost(uint32, tag = "2")]
    pub enrichments_in_use: u32,
    #[prost(uint64, tag = "3")]
    pub size_limit_bytes: u64,
    #[prost(uint32, tag = "4")]
    pub row_limit: u32,
    #[prost(uint64, tag = "5")]
    pub query_only_size_limit_bytes: u64,
    #[prost(uint32, tag = "6")]
    pub query_only_row_limit: u32,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct GetEnrichmentLimitRequest {}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct GetEnrichmentLimitResponse {
    #[prost(uint32, tag = "1")]
    pub limit: u32,
    #[prost(uint32, tag = "2")]
    pub used: u32,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct GetEnrichmentsRequest {}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetEnrichmentsResponse {
    #[prost(message, repeated, tag = "1")]
    pub enrichments: ::prost::alloc::vec::Vec<Enrichment>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AddEnrichmentsRequest {
    #[prost(message, repeated, tag = "1")]
    pub request_enrichments: ::prost::alloc::vec::Vec<EnrichmentRequestModel>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AddEnrichmentsResponse {
    #[prost(message, repeated, tag = "1")]
    pub enrichments: ::prost::alloc::vec::Vec<Enrichment>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RemoveEnrichmentsRequest {
    #[prost(message, repeated, tag = "1")]
    pub enrichment_ids: ::prost::alloc::vec::Vec<u32>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RemoveEnrichmentsResponse {
    #[prost(message, repeated, tag = "1")]
    pub remaining_enrichments: ::prost::alloc::vec::Vec<Enrichment>,
}
/// Deletes all enrichments of the given type and replaces them with the new ones
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AtomicOverwriteEnrichmentsRequest {
    #[prost(message, optional, tag = "1")]
    pub enrichment_type: ::core::option::Option<EnrichmentType>,
    #[prost(message, repeated, tag = "2")]
    pub enrichment_fields: ::prost::alloc::vec::Vec<EnrichmentFieldDefinition>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AtomicOverwriteEnrichmentsResponse {
    #[prost(message, repeated, tag = "1")]
    pub enrichments: ::prost::alloc::vec::Vec<Enrichment>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct GetCompanyEnrichmentSettingsRequest {}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct GetCompanyEnrichmentSettingsResponse {
    #[prost(message, optional, tag = "1")]
    pub enrichment_settings: ::core::option::Option<CompanyEnrichmentSettings>,
}
/// Generated client implementations.
pub mod enrichment_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 EnrichmentServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl EnrichmentServiceClient<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> EnrichmentServiceClient<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,
        ) -> EnrichmentServiceClient<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,
        {
            EnrichmentServiceClient::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_enrichments(
            &mut self,
            request: impl tonic::IntoRequest<super::GetEnrichmentsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetEnrichmentsResponse>,
            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.enrichment.v1.EnrichmentService/GetEnrichments",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "com.coralogix.enrichment.v1.EnrichmentService",
                        "GetEnrichments",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn add_enrichments(
            &mut self,
            request: impl tonic::IntoRequest<super::AddEnrichmentsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::AddEnrichmentsResponse>,
            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.enrichment.v1.EnrichmentService/AddEnrichments",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "com.coralogix.enrichment.v1.EnrichmentService",
                        "AddEnrichments",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn remove_enrichments(
            &mut self,
            request: impl tonic::IntoRequest<super::RemoveEnrichmentsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::RemoveEnrichmentsResponse>,
            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.enrichment.v1.EnrichmentService/RemoveEnrichments",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "com.coralogix.enrichment.v1.EnrichmentService",
                        "RemoveEnrichments",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_enrichment_limit(
            &mut self,
            request: impl tonic::IntoRequest<super::GetEnrichmentLimitRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetEnrichmentLimitResponse>,
            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.enrichment.v1.EnrichmentService/GetEnrichmentLimit",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "com.coralogix.enrichment.v1.EnrichmentService",
                        "GetEnrichmentLimit",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn atomic_overwrite_enrichments(
            &mut self,
            request: impl tonic::IntoRequest<super::AtomicOverwriteEnrichmentsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::AtomicOverwriteEnrichmentsResponse>,
            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.enrichment.v1.EnrichmentService/AtomicOverwriteEnrichments",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "com.coralogix.enrichment.v1.EnrichmentService",
                        "AtomicOverwriteEnrichments",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_company_enrichment_settings(
            &mut self,
            request: impl tonic::IntoRequest<super::GetCompanyEnrichmentSettingsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetCompanyEnrichmentSettingsResponse>,
            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.enrichment.v1.EnrichmentService/GetCompanyEnrichmentSettings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "com.coralogix.enrichment.v1.EnrichmentService",
                        "GetCompanyEnrichmentSettings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CustomEnrichment {
    #[prost(uint32, tag = "1")]
    pub id: u32,
    #[prost(string, tag = "3")]
    pub name: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
    #[prost(uint32, tag = "5")]
    pub version: u32,
    #[prost(bool, tag = "6")]
    pub is_query_only: bool,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CustomEnrichmentData {
    #[prost(message, optional, tag = "1")]
    pub definition: ::core::option::Option<CustomEnrichment>,
    #[prost(oneof = "custom_enrichment_data::Content", tags = "3, 4")]
    pub content: ::core::option::Option<custom_enrichment_data::Content>,
}
/// Nested message and enum types in `CustomEnrichmentData`.
pub mod custom_enrichment_data {
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Content {
        #[prost(message, tag = "3")]
        Textual(::prost::alloc::string::String),
        #[prost(message, tag = "4")]
        Binary(::prost::alloc::vec::Vec<u8>),
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct File {
    #[prost(message, optional, tag = "1")]
    pub name: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "2")]
    pub extension: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(oneof = "file::Content", tags = "3, 4")]
    pub content: ::core::option::Option<file::Content>,
}
/// Nested message and enum types in `File`.
pub mod file {
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Content {
        #[prost(message, tag = "3")]
        Textual(::prost::alloc::string::String),
        #[prost(message, tag = "4")]
        Binary(::prost::alloc::vec::Vec<u8>),
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct GetCustomEnrichmentRequest {
    #[prost(message, optional, tag = "1")]
    pub id: ::core::option::Option<u32>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetCustomEnrichmentResponse {
    #[prost(message, optional, tag = "1")]
    pub custom_enrichment: ::core::option::Option<CustomEnrichment>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct GetCustomEnrichmentsRequest {}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetCustomEnrichmentsResponse {
    #[prost(message, repeated, tag = "1")]
    pub custom_enrichments: ::prost::alloc::vec::Vec<CustomEnrichment>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateCustomEnrichmentRequest {
    #[prost(message, optional, tag = "1")]
    pub name: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "2")]
    pub description: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "4")]
    pub file: ::core::option::Option<File>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateCustomEnrichmentResponse {
    #[prost(string, tag = "1")]
    pub message: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub custom_enrichment: ::core::option::Option<CustomEnrichment>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateCustomEnrichmentRequest {
    #[prost(message, optional, tag = "1")]
    pub custom_enrichment_id: ::core::option::Option<u32>,
    #[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 file: ::core::option::Option<File>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateCustomEnrichmentResponse {
    #[prost(string, tag = "1")]
    pub message: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub custom_enrichment: ::core::option::Option<CustomEnrichment>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct DeleteCustomEnrichmentRequest {
    #[prost(message, optional, tag = "2")]
    pub custom_enrichment_id: ::core::option::Option<u32>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteCustomEnrichmentResponse {
    #[prost(string, tag = "1")]
    pub message: ::prost::alloc::string::String,
    #[prost(uint32, tag = "2")]
    pub custom_enrichment_id: u32,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SearchCustomEnrichmentDataRequest {
    #[prost(message, repeated, tag = "1")]
    pub search_clauses: ::prost::alloc::vec::Vec<
        search_custom_enrichment_data_request::SearchClause,
    >,
}
/// Nested message and enum types in `SearchCustomEnrichmentDataRequest`.
pub mod search_custom_enrichment_data_request {
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct SearchClause {
        #[prost(oneof = "search_clause::SearchBy", tags = "1, 2")]
        pub search_by: ::core::option::Option<search_clause::SearchBy>,
    }
    /// Nested message and enum types in `SearchClause`.
    pub mod search_clause {
        #[derive(serde::Serialize, serde::Deserialize)]
        #[serde(rename_all = "snake_case")]
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum SearchBy {
            #[prost(message, tag = "1")]
            Id(u32),
            #[prost(message, tag = "2")]
            Name(::prost::alloc::string::String),
        }
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SearchCustomEnrichmentDataResponse {
    #[prost(message, repeated, tag = "1")]
    pub custom_enrichments_data: ::prost::alloc::vec::Vec<CustomEnrichmentData>,
}
/// Generated client implementations.
pub mod custom_enrichment_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 CustomEnrichmentServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl CustomEnrichmentServiceClient<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> CustomEnrichmentServiceClient<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,
        ) -> CustomEnrichmentServiceClient<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,
        {
            CustomEnrichmentServiceClient::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_custom_enrichment(
            &mut self,
            request: impl tonic::IntoRequest<super::GetCustomEnrichmentRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetCustomEnrichmentResponse>,
            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.enrichment.v1.CustomEnrichmentService/GetCustomEnrichment",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "com.coralogix.enrichment.v1.CustomEnrichmentService",
                        "GetCustomEnrichment",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_custom_enrichments(
            &mut self,
            request: impl tonic::IntoRequest<super::GetCustomEnrichmentsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetCustomEnrichmentsResponse>,
            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.enrichment.v1.CustomEnrichmentService/GetCustomEnrichments",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "com.coralogix.enrichment.v1.CustomEnrichmentService",
                        "GetCustomEnrichments",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn create_custom_enrichment(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateCustomEnrichmentRequest>,
        ) -> std::result::Result<
            tonic::Response<super::CreateCustomEnrichmentResponse>,
            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.enrichment.v1.CustomEnrichmentService/CreateCustomEnrichment",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "com.coralogix.enrichment.v1.CustomEnrichmentService",
                        "CreateCustomEnrichment",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn update_custom_enrichment(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateCustomEnrichmentRequest>,
        ) -> std::result::Result<
            tonic::Response<super::UpdateCustomEnrichmentResponse>,
            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.enrichment.v1.CustomEnrichmentService/UpdateCustomEnrichment",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "com.coralogix.enrichment.v1.CustomEnrichmentService",
                        "UpdateCustomEnrichment",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn delete_custom_enrichment(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteCustomEnrichmentRequest>,
        ) -> std::result::Result<
            tonic::Response<super::DeleteCustomEnrichmentResponse>,
            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.enrichment.v1.CustomEnrichmentService/DeleteCustomEnrichment",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "com.coralogix.enrichment.v1.CustomEnrichmentService",
                        "DeleteCustomEnrichment",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn search_custom_enrichment_data(
            &mut self,
            request: impl tonic::IntoRequest<super::SearchCustomEnrichmentDataRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SearchCustomEnrichmentDataResponse>,
            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.enrichment.v1.CustomEnrichmentService/SearchCustomEnrichmentData",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "com.coralogix.enrichment.v1.CustomEnrichmentService",
                        "SearchCustomEnrichmentData",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}