google-api-proto 1.710.0

// This file is @generated by prost-build.
/// A floating point interval.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct Interval {
    /// The lower bound of the interval. If neither of the min fields are
    /// set, then the lower bound is negative infinity.
    ///
    /// This field must be not larger than max.
    /// Otherwise, an `INVALID_ARGUMENT` error is returned.
    #[prost(oneof = "interval::Min", tags = "1, 2")]
    pub min: ::core::option::Option<interval::Min>,
    /// The upper bound of the interval. If neither of the max fields are
    /// set, then the upper bound is positive infinity.
    ///
    /// This field must be not smaller than min.
    /// Otherwise, an `INVALID_ARGUMENT` error is returned.
    #[prost(oneof = "interval::Max", tags = "3, 4")]
    pub max: ::core::option::Option<interval::Max>,
}
/// Nested message and enum types in `Interval`.
pub mod interval {
    /// The lower bound of the interval. If neither of the min fields are
    /// set, then the lower bound is negative infinity.
    ///
    /// This field must be not larger than max.
    /// Otherwise, an `INVALID_ARGUMENT` error is returned.
    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
    pub enum Min {
        /// Inclusive lower bound.
        #[prost(double, tag = "1")]
        Minimum(f64),
        /// Exclusive lower bound.
        #[prost(double, tag = "2")]
        ExclusiveMinimum(f64),
    }
    /// The upper bound of the interval. If neither of the max fields are
    /// set, then the upper bound is positive infinity.
    ///
    /// This field must be not smaller than min.
    /// Otherwise, an `INVALID_ARGUMENT` error is returned.
    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
    pub enum Max {
        /// Inclusive upper bound.
        #[prost(double, tag = "3")]
        Maximum(f64),
        /// Exclusive upper bound.
        #[prost(double, tag = "4")]
        ExclusiveMaximum(f64),
    }
}
/// A custom attribute that is not explicitly modeled in a resource, e.g.
/// [UserEvent][google.cloud.discoveryengine.v1alpha.UserEvent].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CustomAttribute {
    /// The textual values of this custom attribute. For example, `["yellow",
    /// "green"]` when the key is "color".
    ///
    /// Empty string is not allowed. Otherwise, an `INVALID_ARGUMENT` error is
    /// returned.
    ///
    /// Exactly one of
    /// [CustomAttribute.text][google.cloud.discoveryengine.v1alpha.CustomAttribute.text]
    /// or
    /// [CustomAttribute.numbers][google.cloud.discoveryengine.v1alpha.CustomAttribute.numbers]
    /// should be set. Otherwise, an `INVALID_ARGUMENT` error is returned.
    #[prost(string, repeated, tag = "1")]
    pub text: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// The numerical values of this custom attribute. For example, `\[2.3, 15.4\]`
    /// when the key is "lengths_cm".
    ///
    /// Exactly one of
    /// [CustomAttribute.text][google.cloud.discoveryengine.v1alpha.CustomAttribute.text]
    /// or
    /// [CustomAttribute.numbers][google.cloud.discoveryengine.v1alpha.CustomAttribute.numbers]
    /// should be set. Otherwise, an `INVALID_ARGUMENT` error is returned.
    #[prost(double, repeated, tag = "2")]
    pub numbers: ::prost::alloc::vec::Vec<f64>,
}
/// Information of an end user.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UserInfo {
    /// Highly recommended for logged-in users. Unique identifier for logged-in
    /// user, such as a user name. Don't set for anonymous users.
    ///
    /// Always use a hashed value for this ID.
    ///
    /// Don't set the field to the same fixed ID for different users. This mixes
    /// the event history of those users together, which results in degraded
    /// model quality.
    ///
    /// The field must be a UTF-8 encoded string with a length limit of 128
    /// characters. Otherwise, an `INVALID_ARGUMENT` error is returned.
    #[prost(string, tag = "1")]
    pub user_id: ::prost::alloc::string::String,
    /// User agent as included in the HTTP header.
    ///
    /// The field must be a UTF-8 encoded string with a length limit of 1,000
    /// characters. Otherwise, an `INVALID_ARGUMENT` error is returned.
    ///
    /// This should not be set when using the client side event reporting with
    /// GTM or JavaScript tag in
    /// [UserEventService.CollectUserEvent][google.cloud.discoveryengine.v1alpha.UserEventService.CollectUserEvent]
    /// or if
    /// [UserEvent.direct_user_request][google.cloud.discoveryengine.v1alpha.UserEvent.direct_user_request]
    /// is set.
    #[prost(string, tag = "2")]
    pub user_agent: ::prost::alloc::string::String,
}
/// Defines embedding config, used for bring your own embeddings feature.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EmbeddingConfig {
    /// Full field path in the schema mapped as embedding field.
    #[prost(string, tag = "1")]
    pub field_path: ::prost::alloc::string::String,
}
/// Double list.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DoubleList {
    /// Double values.
    #[prost(double, repeated, tag = "1")]
    pub values: ::prost::alloc::vec::Vec<f64>,
}
/// Defines guided search spec.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct GuidedSearchSpec {
    /// Whether or not to enable and include refinement attributes in gudied search
    /// result.
    #[prost(bool, tag = "1")]
    pub enable_refinement_attributes: bool,
    /// Whether or not to enable and include related questions in search response.
    #[prost(bool, tag = "2")]
    pub enable_related_questions: bool,
    /// Max number of related questions to be returned. The valid range is \[1, 5\].
    /// If enable_related_questions is true, the default value is 3.
    #[prost(int32, tag = "3")]
    pub max_related_questions: i32,
}
/// Defines custom fine tuning spec.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct CustomFineTuningSpec {
    /// Whether or not to enable and include custom fine tuned search adaptor
    /// model.
    #[prost(bool, tag = "1")]
    pub enable_search_adaptor: bool,
}
/// Identity Provider Config.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct IdpConfig {
    /// Identity provider type configured.
    #[prost(enumeration = "idp_config::IdpType", tag = "1")]
    pub idp_type: i32,
    /// External Identity provider config.
    #[prost(message, optional, tag = "2")]
    pub external_idp_config: ::core::option::Option<idp_config::ExternalIdpConfig>,
}
/// Nested message and enum types in `IdpConfig`.
pub mod idp_config {
    /// Third party IDP Config.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ExternalIdpConfig {
        /// Workforce pool name.
        /// Example: "locations/global/workforcePools/pool_id"
        #[prost(string, tag = "1")]
        pub workforce_pool_name: ::prost::alloc::string::String,
    }
    /// Identity Provider Type.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum IdpType {
        /// Default value. ACL search not enabled.
        Unspecified = 0,
        /// Google 1P provider.
        Gsuite = 1,
        /// Third party provider.
        ThirdParty = 2,
    }
    impl IdpType {
        /// 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 {
                IdpType::Unspecified => "IDP_TYPE_UNSPECIFIED",
                IdpType::Gsuite => "GSUITE",
                IdpType::ThirdParty => "THIRD_PARTY",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "IDP_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "GSUITE" => Some(Self::Gsuite),
                "THIRD_PARTY" => Some(Self::ThirdParty),
                _ => None,
            }
        }
    }
}
/// Principal identifier of a user or a group.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Principal {
    /// Union field principal. Principal can be a user or a group.
    #[prost(oneof = "principal::Principal", tags = "1, 2")]
    pub principal: ::core::option::Option<principal::Principal>,
}
/// Nested message and enum types in `Principal`.
pub mod principal {
    /// Union field principal. Principal can be a user or a group.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Principal {
        /// User identifier.
        /// For Google Workspace user account, user_id should be the google workspace
        /// user email.
        /// For non-google identity provider user account, user_id is the mapped user
        /// identifier configured during the workforcepool config.
        #[prost(string, tag = "1")]
        UserId(::prost::alloc::string::String),
        /// Group identifier.
        /// For Google Workspace user account, group_id should be the google
        /// workspace group email.
        /// For non-google identity provider user account, group_id is the mapped
        /// group identifier configured during the workforcepool config.
        #[prost(string, tag = "2")]
        GroupId(::prost::alloc::string::String),
    }
}
/// The industry vertical associated with the
/// [DataStore][google.cloud.discoveryengine.v1alpha.DataStore].
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum IndustryVertical {
    /// Value used when unset.
    Unspecified = 0,
    /// The generic vertical for documents that are not specific to any industry
    /// vertical.
    Generic = 1,
    /// The media industry vertical.
    Media = 2,
    /// The healthcare FHIR vertical.
    HealthcareFhir = 7,
}
impl IndustryVertical {
    /// 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 {
            IndustryVertical::Unspecified => "INDUSTRY_VERTICAL_UNSPECIFIED",
            IndustryVertical::Generic => "GENERIC",
            IndustryVertical::Media => "MEDIA",
            IndustryVertical::HealthcareFhir => "HEALTHCARE_FHIR",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "INDUSTRY_VERTICAL_UNSPECIFIED" => Some(Self::Unspecified),
            "GENERIC" => Some(Self::Generic),
            "MEDIA" => Some(Self::Media),
            "HEALTHCARE_FHIR" => Some(Self::HealthcareFhir),
            _ => None,
        }
    }
}
/// The type of solution.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SolutionType {
    /// Default value.
    Unspecified = 0,
    /// Used for Recommendations AI.
    Recommendation = 1,
    /// Used for Discovery Search.
    Search = 2,
    /// Used for use cases related to the Generative AI agent.
    Chat = 3,
    /// Used for use cases related to the Generative Chat agent.
    /// It's used for Generative chat engine only, the associated data stores
    /// must enrolled with `SOLUTION_TYPE_CHAT` solution.
    GenerativeChat = 4,
}
impl SolutionType {
    /// 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 {
            SolutionType::Unspecified => "SOLUTION_TYPE_UNSPECIFIED",
            SolutionType::Recommendation => "SOLUTION_TYPE_RECOMMENDATION",
            SolutionType::Search => "SOLUTION_TYPE_SEARCH",
            SolutionType::Chat => "SOLUTION_TYPE_CHAT",
            SolutionType::GenerativeChat => "SOLUTION_TYPE_GENERATIVE_CHAT",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "SOLUTION_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
            "SOLUTION_TYPE_RECOMMENDATION" => Some(Self::Recommendation),
            "SOLUTION_TYPE_SEARCH" => Some(Self::Search),
            "SOLUTION_TYPE_CHAT" => Some(Self::Chat),
            "SOLUTION_TYPE_GENERATIVE_CHAT" => Some(Self::GenerativeChat),
            _ => None,
        }
    }
}
/// Defines a further subdivision of `SolutionType`.
/// Specifically applies to
/// [SOLUTION_TYPE_SEARCH][google.cloud.discoveryengine.v1alpha.SolutionType.SOLUTION_TYPE_SEARCH].
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SearchUseCase {
    /// Value used when unset. Will not occur in CSS.
    Unspecified = 0,
    /// Search use case. Expects the traffic has a non-empty
    /// [query][google.cloud.discoveryengine.v1alpha.SearchRequest.query].
    Search = 1,
    /// Browse use case. Expects the traffic has an empty
    /// [query][google.cloud.discoveryengine.v1alpha.SearchRequest.query].
    Browse = 2,
}
impl SearchUseCase {
    /// 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 {
            SearchUseCase::Unspecified => "SEARCH_USE_CASE_UNSPECIFIED",
            SearchUseCase::Search => "SEARCH_USE_CASE_SEARCH",
            SearchUseCase::Browse => "SEARCH_USE_CASE_BROWSE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "SEARCH_USE_CASE_UNSPECIFIED" => Some(Self::Unspecified),
            "SEARCH_USE_CASE_SEARCH" => Some(Self::Search),
            "SEARCH_USE_CASE_BROWSE" => Some(Self::Browse),
            _ => None,
        }
    }
}
/// Tiers of search features. Different tiers might have different
/// pricing. To learn more, check the pricing documentation.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SearchTier {
    /// Default value when the enum is unspecified. This is invalid to use.
    Unspecified = 0,
    /// Standard tier.
    Standard = 1,
    /// Enterprise tier.
    Enterprise = 2,
}
impl SearchTier {
    /// 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 {
            SearchTier::Unspecified => "SEARCH_TIER_UNSPECIFIED",
            SearchTier::Standard => "SEARCH_TIER_STANDARD",
            SearchTier::Enterprise => "SEARCH_TIER_ENTERPRISE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "SEARCH_TIER_UNSPECIFIED" => Some(Self::Unspecified),
            "SEARCH_TIER_STANDARD" => Some(Self::Standard),
            "SEARCH_TIER_ENTERPRISE" => Some(Self::Enterprise),
            _ => None,
        }
    }
}
/// Add-on that provides additional functionality for search.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SearchAddOn {
    /// Default value when the enum is unspecified. This is invalid to use.
    Unspecified = 0,
    /// Large language model add-on.
    Llm = 1,
}
impl SearchAddOn {
    /// 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 {
            SearchAddOn::Unspecified => "SEARCH_ADD_ON_UNSPECIFIED",
            SearchAddOn::Llm => "SEARCH_ADD_ON_LLM",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "SEARCH_ADD_ON_UNSPECIFIED" => Some(Self::Unspecified),
            "SEARCH_ADD_ON_LLM" => Some(Self::Llm),
            _ => None,
        }
    }
}
/// Metadata that describes the training and serving parameters of an
/// [Engine][google.cloud.discoveryengine.v1alpha.Engine].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Engine {
    /// Immutable. The fully qualified resource name of the engine.
    ///
    /// This field must be a UTF-8 encoded string with a length limit of 1024
    /// characters.
    ///
    /// Format:
    /// `projects/{project_number}/locations/{location}/collections/{collection}/engines/{engine}`
    /// engine should be 1-63 characters, and valid characters are
    /// /[a-z0-9][a-z0-9-_]*/. Otherwise, an INVALID_ARGUMENT error is returned.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. The display name of the engine. Should be human readable. UTF-8
    /// encoded string with limit of 1024 characters.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// Output only. Timestamp the Recommendation Engine was created at.
    #[prost(message, optional, tag = "3")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Timestamp the Recommendation Engine was last updated.
    #[prost(message, optional, tag = "4")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// The data stores associated with this engine.
    ///
    /// For
    /// [SOLUTION_TYPE_SEARCH][google.cloud.discoveryengine.v1alpha.SolutionType.SOLUTION_TYPE_SEARCH]
    /// and
    /// [SOLUTION_TYPE_RECOMMENDATION][google.cloud.discoveryengine.v1alpha.SolutionType.SOLUTION_TYPE_RECOMMENDATION]
    /// type of engines, they can only associate with at most one data store.
    ///
    /// If
    /// [solution_type][google.cloud.discoveryengine.v1alpha.Engine.solution_type]
    /// is
    /// [SOLUTION_TYPE_CHAT][google.cloud.discoveryengine.v1alpha.SolutionType.SOLUTION_TYPE_CHAT],
    /// multiple [DataStore][google.cloud.discoveryengine.v1alpha.DataStore]s in
    /// the same [Collection][google.cloud.discoveryengine.v1alpha.Collection] can
    /// be associated here.
    ///
    /// Note that when used in
    /// [CreateEngineRequest][google.cloud.discoveryengine.v1alpha.CreateEngineRequest],
    /// one DataStore id must be provided as the system will use it for necessary
    /// initializations.
    #[prost(string, repeated, tag = "5")]
    pub data_store_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Required. The solutions of the engine.
    #[prost(enumeration = "SolutionType", tag = "6")]
    pub solution_type: i32,
    /// The industry vertical that the engine registers.
    /// The restriction of the Engine industry vertical is based on
    /// [DataStore][google.cloud.discoveryengine.v1alpha.DataStore]: If
    /// unspecified, default to `GENERIC`. Vertical on Engine has to match vertical
    /// of the DataStore linked to the engine.
    #[prost(enumeration = "IndustryVertical", tag = "16")]
    pub industry_vertical: i32,
    /// Common config spec that specifies the metadata of the engine.
    #[prost(message, optional, tag = "15")]
    pub common_config: ::core::option::Option<engine::CommonConfig>,
    /// Additional config specs that defines the behavior of the engine.
    #[prost(oneof = "engine::EngineConfig", tags = "9, 11, 13, 14")]
    pub engine_config: ::core::option::Option<engine::EngineConfig>,
    /// Engine metadata to monitor the status of the engine.
    #[prost(oneof = "engine::EngineMetadata", tags = "10, 12")]
    pub engine_metadata: ::core::option::Option<engine::EngineMetadata>,
}
/// Nested message and enum types in `Engine`.
pub mod engine {
    /// Configurations for a Search Engine.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct SearchEngineConfig {
        /// The search feature tier of this engine.
        ///
        /// Different tiers might have different
        /// pricing. To learn more, check the pricing documentation.
        ///
        /// Defaults to
        /// [SearchTier.SEARCH_TIER_STANDARD][google.cloud.discoveryengine.v1alpha.SearchTier.SEARCH_TIER_STANDARD]
        /// if not specified.
        #[prost(enumeration = "super::SearchTier", tag = "1")]
        pub search_tier: i32,
        /// The add-on that this search engine enables.
        #[prost(enumeration = "super::SearchAddOn", repeated, tag = "2")]
        pub search_add_ons: ::prost::alloc::vec::Vec<i32>,
    }
    /// Additional config specs for a `similar-items` engine.
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct SimilarDocumentsEngineConfig {}
    /// Additional config specs for a Media Recommendation engine.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MediaRecommendationEngineConfig {
        /// Required. The type of engine. e.g., `recommended-for-you`.
        ///
        /// This field together with
        /// [optimization_objective][Engine.optimization_objective] describe engine
        /// metadata to use to control engine training and serving.
        ///
        /// Currently supported values: `recommended-for-you`, `others-you-may-like`,
        /// `more-like-this`, `most-popular-items`.
        #[prost(string, tag = "1")]
        pub r#type: ::prost::alloc::string::String,
        /// The optimization objective. e.g., `cvr`.
        ///
        /// This field together with
        /// [optimization_objective][google.cloud.discoveryengine.v1alpha.Engine.MediaRecommendationEngineConfig.type]
        /// describe engine metadata to use to control engine training and serving.
        ///
        /// Currently supported
        /// values: `ctr`, `cvr`.
        ///
        ///   If not specified, we choose default based on engine type.
        /// Default depends on type of recommendation:
        ///
        /// `recommended-for-you` => `ctr`
        ///
        /// `others-you-may-like` => `ctr`
        #[prost(string, tag = "2")]
        pub optimization_objective: ::prost::alloc::string::String,
        /// Name and value of the custom threshold for cvr optimization_objective.
        /// For target_field `watch-time`, target_field_value must be an integer
        /// value indicating the media progress time in seconds between (0, 86400]
        /// (excludes 0, includes 86400) (e.g., 90).
        /// For target_field `watch-percentage`, the target_field_value must be a
        /// valid float value between (0, 1.0] (excludes 0, includes 1.0) (e.g.,
        /// 0.5).
        #[prost(message, optional, tag = "3")]
        pub optimization_objective_config: ::core::option::Option<
            media_recommendation_engine_config::OptimizationObjectiveConfig,
        >,
        /// The training state that the engine is in (e.g.
        /// `TRAINING` or `PAUSED`).
        ///
        /// Since part of the cost of running the service
        /// is frequency of training - this can be used to determine when to train
        /// engine in order to control cost. If not specified: the default value for
        /// `CreateEngine` method is `TRAINING`. The default value for
        /// `UpdateEngine` method is to keep the state the same as before.
        #[prost(
            enumeration = "media_recommendation_engine_config::TrainingState",
            tag = "4"
        )]
        pub training_state: i32,
    }
    /// Nested message and enum types in `MediaRecommendationEngineConfig`.
    pub mod media_recommendation_engine_config {
        /// Custom threshold for `cvr` optimization_objective.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct OptimizationObjectiveConfig {
            /// Required. The name of the field to target. Currently supported
            /// values: `watch-percentage`, `watch-time`.
            #[prost(string, tag = "1")]
            pub target_field: ::prost::alloc::string::String,
            /// Required. The threshold to be applied to the target (e.g., 0.5).
            #[prost(float, tag = "2")]
            pub target_field_value_float: f32,
        }
        /// The training state of the engine.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum TrainingState {
            /// Unspecified training state.
            Unspecified = 0,
            /// The engine training is paused.
            Paused = 1,
            /// The engine is training.
            Training = 2,
        }
        impl TrainingState {
            /// 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 {
                    TrainingState::Unspecified => "TRAINING_STATE_UNSPECIFIED",
                    TrainingState::Paused => "PAUSED",
                    TrainingState::Training => "TRAINING",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "TRAINING_STATE_UNSPECIFIED" => Some(Self::Unspecified),
                    "PAUSED" => Some(Self::Paused),
                    "TRAINING" => Some(Self::Training),
                    _ => None,
                }
            }
        }
    }
    /// Configurations for a Chat Engine.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ChatEngineConfig {
        /// The configurationt generate the Dialogflow agent that is associated to
        /// this Engine.
        ///
        /// Note that these configurations are one-time consumed by
        /// and passed to Dialogflow service. It means they cannot be retrieved using
        /// [EngineService.GetEngine][google.cloud.discoveryengine.v1alpha.EngineService.GetEngine]
        /// or
        /// [EngineService.ListEngines][google.cloud.discoveryengine.v1alpha.EngineService.ListEngines]
        /// API after engine creation.
        #[prost(message, optional, tag = "1")]
        pub agent_creation_config: ::core::option::Option<
            chat_engine_config::AgentCreationConfig,
        >,
        /// The resource name of an exist Dialogflow agent to link to this Chat
        /// Engine. Customers can either provide `agent_creation_config` to create
        /// agent or provide an agent name that links the agent with the Chat engine.
        ///
        /// Format: `projects/<Project ID>/locations/<Location ID>/agents/<Agent
        /// ID>`.
        ///
        /// Note that the `dialogflow_agent_to_link` are one-time consumed by and
        /// passed to Dialogflow service. It means they cannot be retrieved using
        /// [EngineService.GetEngine][google.cloud.discoveryengine.v1alpha.EngineService.GetEngine]
        /// or
        /// [EngineService.ListEngines][google.cloud.discoveryengine.v1alpha.EngineService.ListEngines]
        /// API after engine creation. Use
        /// [ChatEngineMetadata.dialogflow_agent][google.cloud.discoveryengine.v1alpha.Engine.ChatEngineMetadata.dialogflow_agent]
        /// for actual agent association after Engine is created.
        #[prost(string, tag = "2")]
        pub dialogflow_agent_to_link: ::prost::alloc::string::String,
    }
    /// Nested message and enum types in `ChatEngineConfig`.
    pub mod chat_engine_config {
        /// Configurations for generating a Dialogflow agent.
        ///
        /// Note that these configurations are one-time consumed by
        /// and passed to Dialogflow service. It means they cannot be retrieved using
        /// [EngineService.GetEngine][google.cloud.discoveryengine.v1alpha.EngineService.GetEngine]
        /// or
        /// [EngineService.ListEngines][google.cloud.discoveryengine.v1alpha.EngineService.ListEngines]
        /// API after engine creation.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct AgentCreationConfig {
            /// Name of the company, organization or other entity that the agent
            /// represents. Used for knowledge connector LLM prompt and for knowledge
            /// search.
            #[prost(string, tag = "1")]
            pub business: ::prost::alloc::string::String,
            /// Required. The default language of the agent as a language tag.
            /// See [Language
            /// Support](<https://cloud.google.com/dialogflow/docs/reference/language>)
            /// for a list of the currently supported language codes.
            #[prost(string, tag = "2")]
            pub default_language_code: ::prost::alloc::string::String,
            /// Required. The time zone of the agent from the [time zone
            /// database](<https://www.iana.org/time-zones>), e.g., America/New_York,
            /// Europe/Paris.
            #[prost(string, tag = "3")]
            pub time_zone: ::prost::alloc::string::String,
            /// Agent location for Agent creation, supported values: global/us/eu.
            /// If not provided, us Engine will create Agent using us-central-1 by
            /// default; eu Engine will create Agent using eu-west-1 by default.
            #[prost(string, tag = "4")]
            pub location: ::prost::alloc::string::String,
        }
    }
    /// Common configurations for an Engine.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct CommonConfig {
        /// The name of the company, business or entity that is associated with the
        /// engine. Setting this may help improve LLM related features.
        #[prost(string, tag = "1")]
        pub company_name: ::prost::alloc::string::String,
    }
    /// Additional information of a recommendation engine.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RecommendationMetadata {
        /// Output only. The serving state of the engine: `ACTIVE`, `NOT_ACTIVE`.
        #[prost(enumeration = "recommendation_metadata::ServingState", tag = "1")]
        pub serving_state: i32,
        /// Output only. The state of data requirements for this engine: `DATA_OK`
        /// and `DATA_ERROR`.
        ///
        /// Engine cannot be trained if the data is in
        /// `DATA_ERROR` state. Engine can have `DATA_ERROR` state even
        /// if serving state is `ACTIVE`: engines were trained successfully before,
        /// but cannot be refreshed because the underlying engine no longer has
        /// sufficient data for training.
        #[prost(enumeration = "recommendation_metadata::DataState", tag = "2")]
        pub data_state: i32,
        /// Output only. The timestamp when the latest successful tune finished. Only
        /// applicable on Media Recommendation engines.
        #[prost(message, optional, tag = "3")]
        pub last_tune_time: ::core::option::Option<::prost_types::Timestamp>,
        /// Output only. The latest tune operation id associated with the engine.
        /// Only applicable on Media Recommendation engines.
        ///
        /// If present, this operation id can be used to determine if there is an
        /// ongoing tune for this engine. To check the operation status, send the
        /// GetOperation request with this operation id in the engine resource
        /// format. If no tuning has happened for this engine, the string is empty.
        #[prost(string, tag = "4")]
        pub tuning_operation: ::prost::alloc::string::String,
    }
    /// Nested message and enum types in `RecommendationMetadata`.
    pub mod recommendation_metadata {
        /// The serving state of the recommendation engine.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum ServingState {
            /// Unspecified serving state.
            Unspecified = 0,
            /// The engine is not serving.
            Inactive = 1,
            /// The engine is serving and can be queried.
            Active = 2,
            /// The engine is trained on tuned hyperparameters and can be
            /// queried.
            Tuned = 3,
        }
        impl ServingState {
            /// 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 {
                    ServingState::Unspecified => "SERVING_STATE_UNSPECIFIED",
                    ServingState::Inactive => "INACTIVE",
                    ServingState::Active => "ACTIVE",
                    ServingState::Tuned => "TUNED",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "SERVING_STATE_UNSPECIFIED" => Some(Self::Unspecified),
                    "INACTIVE" => Some(Self::Inactive),
                    "ACTIVE" => Some(Self::Active),
                    "TUNED" => Some(Self::Tuned),
                    _ => None,
                }
            }
        }
        /// Describes whether this engine have sufficient training data
        /// to be continuously trained.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum DataState {
            /// Unspecified default value, should never be explicitly set.
            Unspecified = 0,
            /// The engine has sufficient training data.
            DataOk = 1,
            /// The engine does not have sufficient training data. Error
            /// messages can be queried via Stackdriver.
            DataError = 2,
        }
        impl DataState {
            /// 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 {
                    DataState::Unspecified => "DATA_STATE_UNSPECIFIED",
                    DataState::DataOk => "DATA_OK",
                    DataState::DataError => "DATA_ERROR",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "DATA_STATE_UNSPECIFIED" => Some(Self::Unspecified),
                    "DATA_OK" => Some(Self::DataOk),
                    "DATA_ERROR" => Some(Self::DataError),
                    _ => None,
                }
            }
        }
    }
    /// Additional information of a Chat Engine.
    /// Fields in this message are output only.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ChatEngineMetadata {
        /// The resource name of a Dialogflow agent, that this Chat Engine refers
        /// to.
        ///
        /// Format: `projects/<Project ID>/locations/<Location ID>/agents/<Agent
        /// ID>`.
        #[prost(string, tag = "1")]
        pub dialogflow_agent: ::prost::alloc::string::String,
    }
    /// Additional config specs that defines the behavior of the engine.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum EngineConfig {
        /// Additional config specs for a `similar-items` engine.
        #[prost(message, tag = "9")]
        SimilarDocumentsConfig(SimilarDocumentsEngineConfig),
        /// Configurations for the Chat Engine. Only applicable if
        /// [solution_type][google.cloud.discoveryengine.v1alpha.Engine.solution_type]
        /// is
        /// [SOLUTION_TYPE_CHAT][google.cloud.discoveryengine.v1alpha.SolutionType.SOLUTION_TYPE_CHAT].
        #[prost(message, tag = "11")]
        ChatEngineConfig(ChatEngineConfig),
        /// Configurations for the Search Engine. Only applicable if
        /// [solution_type][google.cloud.discoveryengine.v1alpha.Engine.solution_type]
        /// is
        /// [SOLUTION_TYPE_SEARCH][google.cloud.discoveryengine.v1alpha.SolutionType.SOLUTION_TYPE_SEARCH].
        #[prost(message, tag = "13")]
        SearchEngineConfig(SearchEngineConfig),
        /// Configurations for the Media Engine. Only applicable on the data
        /// stores with
        /// [solution_type][google.cloud.discoveryengine.v1alpha.Engine.solution_type]
        /// [SOLUTION_TYPE_RECOMMENDATION][google.cloud.discoveryengine.v1alpha.SolutionType.SOLUTION_TYPE_RECOMMENDATION]
        /// and
        /// [IndustryVertical.MEDIA][google.cloud.discoveryengine.v1alpha.IndustryVertical.MEDIA]
        /// vertical.
        #[prost(message, tag = "14")]
        MediaRecommendationEngineConfig(MediaRecommendationEngineConfig),
    }
    /// Engine metadata to monitor the status of the engine.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum EngineMetadata {
        /// Output only. Additional information of a recommendation engine. Only
        /// applicable if
        /// [solution_type][google.cloud.discoveryengine.v1alpha.Engine.solution_type]
        /// is
        /// [SOLUTION_TYPE_RECOMMENDATION][google.cloud.discoveryengine.v1alpha.SolutionType.SOLUTION_TYPE_RECOMMENDATION].
        #[prost(message, tag = "10")]
        RecommendationMetadata(RecommendationMetadata),
        /// Output only. Additional information of the Chat Engine. Only applicable
        /// if
        /// [solution_type][google.cloud.discoveryengine.v1alpha.Engine.solution_type]
        /// is
        /// [SOLUTION_TYPE_CHAT][google.cloud.discoveryengine.v1alpha.SolutionType.SOLUTION_TYPE_CHAT].
        #[prost(message, tag = "12")]
        ChatEngineMetadata(ChatEngineMetadata),
    }
}
/// Chunk captures all raw metadata information of items to be recommended or
/// searched in the chunk mode.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Chunk {
    /// The full resource name of the chunk.
    /// Format:
    /// `projects/{project}/locations/{location}/collections/{collection}/dataStores/{data_store}/branches/{branch}/documents/{document_id}/chunks/{chunk_id}`.
    ///
    /// This field must be a UTF-8 encoded string with a length limit of 1024
    /// characters.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Unique chunk ID of the current chunk.
    #[prost(string, tag = "2")]
    pub id: ::prost::alloc::string::String,
    /// Content is a string from a document (parsed content).
    #[prost(string, tag = "3")]
    pub content: ::prost::alloc::string::String,
    /// Output only. Represents the relevance score based on similarity.
    /// Higher score indicates higher chunk relevance.
    /// The score is in range \[-1.0, 1.0\].
    /// Only populated on [SearchService.SearchResponse][].
    #[prost(double, optional, tag = "8")]
    pub relevance_score: ::core::option::Option<f64>,
    /// Metadata of the document from the current chunk.
    #[prost(message, optional, tag = "5")]
    pub document_metadata: ::core::option::Option<chunk::DocumentMetadata>,
    /// Output only. This field is OUTPUT_ONLY.
    /// It contains derived data that are not in the original input document.
    #[prost(message, optional, tag = "4")]
    pub derived_struct_data: ::core::option::Option<::prost_types::Struct>,
    /// Page span of the chunk.
    #[prost(message, optional, tag = "6")]
    pub page_span: ::core::option::Option<chunk::PageSpan>,
    /// Output only. Metadata of the current chunk.
    #[prost(message, optional, tag = "7")]
    pub chunk_metadata: ::core::option::Option<chunk::ChunkMetadata>,
}
/// Nested message and enum types in `Chunk`.
pub mod chunk {
    /// Document metadata contains the information of the document of the current
    /// chunk.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct DocumentMetadata {
        /// Uri of the document.
        #[prost(string, tag = "1")]
        pub uri: ::prost::alloc::string::String,
        /// Title of the document.
        #[prost(string, tag = "2")]
        pub title: ::prost::alloc::string::String,
        /// Data representation.
        /// The structured JSON data for the document. It should conform to the
        /// registered [Schema][google.cloud.discoveryengine.v1alpha.Schema] or an
        /// `INVALID_ARGUMENT` error is thrown.
        #[prost(message, optional, tag = "3")]
        pub struct_data: ::core::option::Option<::prost_types::Struct>,
    }
    /// Page span of the chunk.
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct PageSpan {
        /// The start page of the chunk.
        #[prost(int32, tag = "1")]
        pub page_start: i32,
        /// The end page of the chunk.
        #[prost(int32, tag = "2")]
        pub page_end: i32,
    }
    /// Metadata of the current chunk. This field is only populated on
    /// [SearchService.Search][google.cloud.discoveryengine.v1alpha.SearchService.Search]
    /// API.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ChunkMetadata {
        /// The previous chunks of the current chunk. The number is controlled by
        /// [SearchRequest.ContentSearchSpec.ChunkSpec.num_previous_chunks][google.cloud.discoveryengine.v1alpha.SearchRequest.ContentSearchSpec.ChunkSpec.num_previous_chunks].
        /// This field is only populated on
        /// [SearchService.Search][google.cloud.discoveryengine.v1alpha.SearchService.Search]
        /// API.
        #[prost(message, repeated, tag = "1")]
        pub previous_chunks: ::prost::alloc::vec::Vec<super::Chunk>,
        /// The next chunks of the current chunk. The number is controlled by
        /// [SearchRequest.ContentSearchSpec.ChunkSpec.num_next_chunks][google.cloud.discoveryengine.v1alpha.SearchRequest.ContentSearchSpec.ChunkSpec.num_next_chunks].
        /// This field is only populated on
        /// [SearchService.Search][google.cloud.discoveryengine.v1alpha.SearchService.Search]
        /// API.
        #[prost(message, repeated, tag = "2")]
        pub next_chunks: ::prost::alloc::vec::Vec<super::Chunk>,
    }
}
/// Document captures all raw metadata information of items to be recommended or
/// searched.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Document {
    /// Immutable. The full resource name of the document.
    /// Format:
    /// `projects/{project}/locations/{location}/collections/{collection}/dataStores/{data_store}/branches/{branch}/documents/{document_id}`.
    ///
    /// This field must be a UTF-8 encoded string with a length limit of 1024
    /// characters.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Immutable. The identifier of the document.
    ///
    /// Id should conform to [RFC-1034](<https://tools.ietf.org/html/rfc1034>)
    /// standard with a length limit of 63 characters.
    #[prost(string, tag = "2")]
    pub id: ::prost::alloc::string::String,
    /// The identifier of the schema located in the same data store.
    #[prost(string, tag = "3")]
    pub schema_id: ::prost::alloc::string::String,
    /// The unstructured data linked to this document. Content must be set if this
    /// document is under a
    /// `CONTENT_REQUIRED` data store.
    #[prost(message, optional, tag = "10")]
    pub content: ::core::option::Option<document::Content>,
    /// The identifier of the parent document. Currently supports at most two level
    /// document hierarchy.
    ///
    /// Id should conform to [RFC-1034](<https://tools.ietf.org/html/rfc1034>)
    /// standard with a length limit of 63 characters.
    #[prost(string, tag = "7")]
    pub parent_document_id: ::prost::alloc::string::String,
    /// Output only. This field is OUTPUT_ONLY.
    /// It contains derived data that are not in the original input document.
    #[prost(message, optional, tag = "6")]
    pub derived_struct_data: ::core::option::Option<::prost_types::Struct>,
    /// Access control information for the document.
    #[prost(message, optional, tag = "11")]
    pub acl_info: ::core::option::Option<document::AclInfo>,
    /// Output only. The last time the document was indexed. If this field is set,
    /// the document could be returned in search results.
    ///
    /// This field is OUTPUT_ONLY. If this field is not populated, it means the
    /// document has never been indexed.
    #[prost(message, optional, tag = "13")]
    pub index_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The index status of the document.
    ///
    /// * If document is indexed successfully, the index_time field is populated.
    /// * Otherwise, if document is not indexed due to errors, the error_samples
    ///    field is populated.
    /// * Otherwise, index_status is unset.
    #[prost(message, optional, tag = "15")]
    pub index_status: ::core::option::Option<document::IndexStatus>,
    /// Data representation. One of
    /// [struct_data][google.cloud.discoveryengine.v1alpha.Document.struct_data] or
    /// [json_data][google.cloud.discoveryengine.v1alpha.Document.json_data] should
    /// be provided otherwise an `INVALID_ARGUMENT` error is thrown.
    #[prost(oneof = "document::Data", tags = "4, 5")]
    pub data: ::core::option::Option<document::Data>,
}
/// Nested message and enum types in `Document`.
pub mod document {
    /// Unstructured data linked to this document.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Content {
        /// The MIME type of the content. Supported types:
        ///
        /// * `application/pdf` (PDF, only native PDFs are supported for now)
        /// * `text/html` (HTML)
        /// * `application/vnd.openxmlformats-officedocument.wordprocessingml.document` (DOCX)
        /// * `application/vnd.openxmlformats-officedocument.presentationml.presentation` (PPTX)
        /// * `text/plain` (TXT)
        ///
        /// See <https://www.iana.org/assignments/media-types/media-types.xhtml.>
        #[prost(string, tag = "1")]
        pub mime_type: ::prost::alloc::string::String,
        #[prost(oneof = "content::Content", tags = "2, 3")]
        pub content: ::core::option::Option<content::Content>,
    }
    /// Nested message and enum types in `Content`.
    pub mod content {
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum Content {
            /// The content represented as a stream of bytes. The maximum length is
            /// 1,000,000 bytes (1 MB / ~0.95 MiB).
            ///
            /// Note: As with all `bytes` fields, this field is represented as pure
            /// binary in Protocol Buffers and base64-encoded string in JSON. For
            /// example, `abc123!?$*&()'-=@~` should be represented as
            /// `YWJjMTIzIT8kKiYoKSctPUB+` in JSON. See
            /// <https://developers.google.com/protocol-buffers/docs/proto3#json.>
            #[prost(bytes, tag = "2")]
            RawBytes(::prost::bytes::Bytes),
            /// The URI of the content. Only Cloud Storage URIs (e.g.
            /// `gs://bucket-name/path/to/file`) are supported. The maximum file size
            /// is 2.5 MB for text-based formats, 200 MB for other formats.
            #[prost(string, tag = "3")]
            Uri(::prost::alloc::string::String),
        }
    }
    /// ACL Information of the Document.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct AclInfo {
        /// Readers of the document.
        #[prost(message, repeated, tag = "1")]
        pub readers: ::prost::alloc::vec::Vec<acl_info::AccessRestriction>,
    }
    /// Nested message and enum types in `AclInfo`.
    pub mod acl_info {
        /// AclRestriction to model complex inheritance restrictions.
        ///
        /// Example: Modeling a "Both Permit" inheritance, where to access a
        /// child document, user needs to have access to parent document.
        ///
        /// Document Hierarchy - Space_S --> Page_P.
        ///
        /// Readers:
        ///    Space_S: group_1, user_1
        ///    Page_P: group_2, group_3, user_2
        ///
        /// Space_S ACL Restriction -
        /// {
        ///    "acl_info": {
        ///      "readers": [
        ///        {
        ///          "principals": [
        ///            {
        ///              "group_id": "group_1"
        ///            },
        ///            {
        ///              "user_id": "user_1"
        ///            }
        ///          ]
        ///        }
        ///      ]
        ///    }
        /// }
        ///
        /// Page_P ACL Restriction.
        /// {
        ///    "acl_info": {
        ///      "readers": [
        ///        {
        ///          "principals": [
        ///            {
        ///              "group_id": "group_2"
        ///            },
        ///            {
        ///              "group_id": "group_3"
        ///            },
        ///            {
        ///              "user_id": "user_2"
        ///            }
        ///          ],
        ///        },
        ///        {
        ///          "principals": [
        ///            {
        ///              "group_id": "group_1"
        ///            },
        ///            {
        ///              "user_id": "user_1"
        ///            }
        ///          ],
        ///        }
        ///      ]
        ///    }
        /// }
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct AccessRestriction {
            /// List of principals.
            #[prost(message, repeated, tag = "1")]
            pub principals: ::prost::alloc::vec::Vec<super::super::Principal>,
            /// All users within the Identity Provider.
            #[prost(bool, tag = "2")]
            pub idp_wide: bool,
        }
    }
    /// Index status of the document.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct IndexStatus {
        /// The time when the document was indexed.
        /// If this field is populated, it means the document has been indexed.
        #[prost(message, optional, tag = "1")]
        pub index_time: ::core::option::Option<::prost_types::Timestamp>,
        /// A sample of errors encountered while indexing the document.
        /// If this field is populated, the document is not indexed due to errors.
        #[prost(message, repeated, tag = "2")]
        pub error_samples: ::prost::alloc::vec::Vec<
            super::super::super::super::rpc::Status,
        >,
    }
    /// Data representation. One of
    /// [struct_data][google.cloud.discoveryengine.v1alpha.Document.struct_data] or
    /// [json_data][google.cloud.discoveryengine.v1alpha.Document.json_data] should
    /// be provided otherwise an `INVALID_ARGUMENT` error is thrown.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Data {
        /// The structured JSON data for the document. It should conform to the
        /// registered [Schema][google.cloud.discoveryengine.v1alpha.Schema] or an
        /// `INVALID_ARGUMENT` error is thrown.
        #[prost(message, tag = "4")]
        StructData(::prost_types::Struct),
        /// The JSON string representation of the document. It should conform to the
        /// registered [Schema][google.cloud.discoveryengine.v1alpha.Schema] or an
        /// `INVALID_ARGUMENT` error is thrown.
        #[prost(string, tag = "5")]
        JsonData(::prost::alloc::string::String),
    }
}
/// Document captures all raw metadata information of items to be recommended or
/// searched.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ProcessedDocument {
    /// Required. Full resource name of the referenced document, in the format
    /// `projects/*/locations/*/collections/*/dataStores/*/branches/*/documents/*`.
    #[prost(string, tag = "1")]
    pub document: ::prost::alloc::string::String,
    /// Output format of the processed document.
    #[prost(oneof = "processed_document::ProcessedDataFormat", tags = "2")]
    pub processed_data_format: ::core::option::Option<
        processed_document::ProcessedDataFormat,
    >,
}
/// Nested message and enum types in `ProcessedDocument`.
pub mod processed_document {
    /// Output format of the processed document.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum ProcessedDataFormat {
        /// The JSON string representation of the processed document.
        #[prost(string, tag = "2")]
        JsonData(::prost::alloc::string::String),
    }
}
/// Request message for
/// [SearchService.Search][google.cloud.discoveryengine.v1alpha.SearchService.Search]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SearchRequest {
    /// Required. The resource name of the Search serving config, such as
    /// `projects/*/locations/global/collections/default_collection/engines/*/servingConfigs/default_serving_config`,
    /// or
    /// `projects/*/locations/global/collections/default_collection/dataStores/default_data_store/servingConfigs/default_serving_config`.
    /// This field is used to identify the serving configuration name, set
    /// of models used to make the search.
    #[prost(string, tag = "1")]
    pub serving_config: ::prost::alloc::string::String,
    /// The branch resource name, such as
    /// `projects/*/locations/global/collections/default_collection/dataStores/default_data_store/branches/0`.
    ///
    /// Use `default_branch` as the branch ID or leave this field empty, to search
    /// documents under the default branch.
    #[prost(string, tag = "2")]
    pub branch: ::prost::alloc::string::String,
    /// Raw search query.
    #[prost(string, tag = "3")]
    pub query: ::prost::alloc::string::String,
    /// Raw image query.
    #[prost(message, optional, tag = "19")]
    pub image_query: ::core::option::Option<search_request::ImageQuery>,
    /// Maximum number of
    /// [Document][google.cloud.discoveryengine.v1alpha.Document]s to return. The
    /// maximum allowed value depends on the data type. Values above the maximum
    /// value are coerced to the maximum value.
    ///
    /// * Websites with basic indexing: Default `10`, Maximum `25`.
    /// * Websites with advanced indexing: Default `25`, Maximum `50`.
    /// * Other: Default `50`, Maximum `100`.
    ///
    /// If this field is negative, an  `INVALID_ARGUMENT` is returned.
    #[prost(int32, tag = "4")]
    pub page_size: i32,
    /// A page token received from a previous
    /// [SearchService.Search][google.cloud.discoveryengine.v1alpha.SearchService.Search]
    /// call. Provide this to retrieve the subsequent page.
    ///
    /// When paginating, all other parameters provided to
    /// [SearchService.Search][google.cloud.discoveryengine.v1alpha.SearchService.Search]
    /// must match the call that provided the page token. Otherwise, an
    ///   `INVALID_ARGUMENT`  error is returned.
    #[prost(string, tag = "5")]
    pub page_token: ::prost::alloc::string::String,
    /// A 0-indexed integer that specifies the current offset (that is, starting
    /// result location, amongst the
    /// [Document][google.cloud.discoveryengine.v1alpha.Document]s deemed by the
    /// API as relevant) in search results. This field is only considered if
    /// [page_token][google.cloud.discoveryengine.v1alpha.SearchRequest.page_token]
    /// is unset.
    ///
    /// If this field is negative, an  `INVALID_ARGUMENT`  is returned.
    #[prost(int32, tag = "6")]
    pub offset: i32,
    /// Specs defining dataStores to filter on in a search call and configurations
    /// for those dataStores. This is only considered for engines with multiple
    /// dataStores use case. For single dataStore within an engine, they should
    /// use the specs at the top level.
    #[prost(message, repeated, tag = "32")]
    pub data_store_specs: ::prost::alloc::vec::Vec<search_request::DataStoreSpec>,
    /// The filter syntax consists of an expression language for constructing a
    /// predicate from one or more fields of the documents being filtered. Filter
    /// expression is case-sensitive.
    ///
    /// If this field is unrecognizable, an  `INVALID_ARGUMENT`  is returned.
    ///
    /// Filtering in Vertex AI Search is done by mapping the LHS filter key to a
    /// key property defined in the Vertex AI Search backend -- this mapping is
    /// defined by the customer in their schema. For example a media customer might
    /// have a field 'name' in their schema. In this case the filter would look
    /// like this: filter --> name:'ANY("king kong")'
    ///
    /// For more information about filtering including syntax and filter
    /// operators, see
    /// [Filter](<https://cloud.google.com/generative-ai-app-builder/docs/filter-search-metadata>)
    #[prost(string, tag = "7")]
    pub filter: ::prost::alloc::string::String,
    /// The default filter that is applied when a user performs a search without
    /// checking any filters on the search page.
    ///
    /// The filter applied to every search request when quality improvement such as
    /// query expansion is needed. In the case a query does not have a sufficient
    /// amount of results this filter will be used to determine whether or not to
    /// enable the query expansion flow. The original filter will still be used for
    /// the query expanded search.
    /// This field is strongly recommended to achieve high search quality.
    ///
    /// For more information about filter syntax, see
    /// [SearchRequest.filter][google.cloud.discoveryengine.v1alpha.SearchRequest.filter].
    #[prost(string, tag = "29")]
    pub canonical_filter: ::prost::alloc::string::String,
    /// The order in which documents are returned. Documents can be ordered by
    /// a field in an [Document][google.cloud.discoveryengine.v1alpha.Document]
    /// object. Leave it unset if ordered by relevance. `order_by` expression is
    /// case-sensitive.
    ///
    /// For more information on ordering the website search results, see
    /// [Order web search
    /// results](<https://cloud.google.com/generative-ai-app-builder/docs/order-web-search-results>).
    /// For more information on ordering the healthcare search results, see
    /// [Order healthcare search
    /// results](<https://cloud.google.com/generative-ai-app-builder/docs/order-hc-results>).
    /// If this field is unrecognizable, an `INVALID_ARGUMENT` is returned.
    #[prost(string, tag = "8")]
    pub order_by: ::prost::alloc::string::String,
    /// Information about the end user.
    /// Highly recommended for analytics.
    /// [UserInfo.user_agent][google.cloud.discoveryengine.v1alpha.UserInfo.user_agent]
    /// is used to deduce `device_type` for analytics.
    #[prost(message, optional, tag = "21")]
    pub user_info: ::core::option::Option<UserInfo>,
    /// The BCP-47 language code, such as "en-US" or "sr-Latn". For more
    /// information, see [Standard
    /// fields](<https://cloud.google.com/apis/design/standard_fields>). This field
    /// helps to better interpret the query. If a value isn't specified, the query
    /// language code is automatically detected, which may not be accurate.
    #[prost(string, tag = "35")]
    pub language_code: ::prost::alloc::string::String,
    /// The Unicode country/region code (CLDR) of a location, such as "US" and
    /// "419". For more information, see [Standard
    /// fields](<https://cloud.google.com/apis/design/standard_fields>). If set,
    /// then results will be boosted based on the region_code provided.
    #[prost(string, tag = "36")]
    pub region_code: ::prost::alloc::string::String,
    /// Facet specifications for faceted search. If empty, no facets are returned.
    ///
    /// A maximum of 100 values are allowed. Otherwise, an  `INVALID_ARGUMENT`
    /// error is returned.
    #[prost(message, repeated, tag = "9")]
    pub facet_specs: ::prost::alloc::vec::Vec<search_request::FacetSpec>,
    /// Boost specification to boost certain documents.
    /// For more information on boosting, see
    /// [Boosting](<https://cloud.google.com/generative-ai-app-builder/docs/boost-search-results>)
    #[prost(message, optional, tag = "10")]
    pub boost_spec: ::core::option::Option<search_request::BoostSpec>,
    /// Additional search parameters.
    ///
    /// For public website search only, supported values are:
    ///
    /// * `user_country_code`: string. Default empty. If set to non-empty, results
    ///     are restricted or boosted based on the location provided.
    ///     For example, `user_country_code: "au"`
    ///
    ///     For available codes see [Country
    ///     Codes](<https://developers.google.com/custom-search/docs/json_api_reference#countryCodes>)
    ///
    /// * `search_type`: double. Default empty. Enables non-webpage searching
    ///     depending on the value. The only valid non-default value is 1,
    ///     which enables image searching.
    ///     For example, `search_type: 1`
    #[prost(btree_map = "string, message", tag = "11")]
    pub params: ::prost::alloc::collections::BTreeMap<
        ::prost::alloc::string::String,
        ::prost_types::Value,
    >,
    /// The query expansion specification that specifies the conditions under which
    /// query expansion occurs.
    #[prost(message, optional, tag = "13")]
    pub query_expansion_spec: ::core::option::Option<search_request::QueryExpansionSpec>,
    /// The spell correction specification that specifies the mode under
    /// which spell correction takes effect.
    #[prost(message, optional, tag = "14")]
    pub spell_correction_spec: ::core::option::Option<
        search_request::SpellCorrectionSpec,
    >,
    /// A unique identifier for tracking visitors. For example, this could be
    /// implemented with an HTTP cookie, which should be able to uniquely identify
    /// a visitor on a single device. This unique identifier should not change if
    /// the visitor logs in or out of the website.
    ///
    /// This field should NOT have a fixed value such as `unknown_visitor`.
    ///
    /// This should be the same identifier as
    /// [UserEvent.user_pseudo_id][google.cloud.discoveryengine.v1alpha.UserEvent.user_pseudo_id]
    /// and
    /// [CompleteQueryRequest.user_pseudo_id][google.cloud.discoveryengine.v1alpha.CompleteQueryRequest.user_pseudo_id]
    ///
    /// The field must be a UTF-8 encoded string with a length limit of 128
    /// characters. Otherwise, an  `INVALID_ARGUMENT`  error is returned.
    #[prost(string, tag = "15")]
    pub user_pseudo_id: ::prost::alloc::string::String,
    /// A specification for configuring the behavior of content search.
    #[prost(message, optional, tag = "24")]
    pub content_search_spec: ::core::option::Option<search_request::ContentSearchSpec>,
    /// Uses the provided embedding to do additional semantic document retrieval.
    /// The retrieval is based on the dot product of
    /// [SearchRequest.EmbeddingSpec.EmbeddingVector.vector][google.cloud.discoveryengine.v1alpha.SearchRequest.EmbeddingSpec.EmbeddingVector.vector]
    /// and the document embedding that is provided in
    /// [SearchRequest.EmbeddingSpec.EmbeddingVector.field_path][google.cloud.discoveryengine.v1alpha.SearchRequest.EmbeddingSpec.EmbeddingVector.field_path].
    ///
    /// If
    /// [SearchRequest.EmbeddingSpec.EmbeddingVector.field_path][google.cloud.discoveryengine.v1alpha.SearchRequest.EmbeddingSpec.EmbeddingVector.field_path]
    /// is not provided, it will use
    /// [ServingConfig.EmbeddingConfig.field_path][google.cloud.discoveryengine.v1alpha.ServingConfig.embedding_config].
    #[prost(message, optional, tag = "23")]
    pub embedding_spec: ::core::option::Option<search_request::EmbeddingSpec>,
    /// The ranking expression controls the customized ranking on retrieval
    /// documents. This overrides
    /// [ServingConfig.ranking_expression][google.cloud.discoveryengine.v1alpha.ServingConfig.ranking_expression].
    /// The ranking expression is a single function or multiple functions that are
    /// joined by "+".
    ///
    ///    * ranking_expression = function, { " + ", function };
    ///
    /// Supported functions:
    ///
    ///    * double * relevance_score
    ///    * double * dotProduct(embedding_field_path)
    ///
    /// Function variables:
    ///
    ///    * `relevance_score`: pre-defined keywords, used for measure relevance
    ///    between query and document.
    ///    * `embedding_field_path`: the document embedding field
    ///    used with query embedding vector.
    ///    * `dotProduct`: embedding function between embedding_field_path and query
    ///    embedding vector.
    ///
    ///   Example ranking expression:
    ///
    ///     If document has an embedding field doc_embedding, the ranking expression
    ///     could be `0.5 * relevance_score + 0.3 * dotProduct(doc_embedding)`.
    #[prost(string, tag = "26")]
    pub ranking_expression: ::prost::alloc::string::String,
    /// Whether to turn on safe search. This is only supported for
    /// website search.
    #[prost(bool, tag = "20")]
    pub safe_search: bool,
    /// The user labels applied to a resource must meet the following requirements:
    ///
    /// * Each resource can have multiple labels, up to a maximum of 64.
    /// * Each label must be a key-value pair.
    /// * Keys have a minimum length of 1 character and a maximum length of 63
    ///    characters and cannot be empty. Values can be empty and have a maximum
    ///    length of 63 characters.
    /// * Keys and values can contain only lowercase letters, numeric characters,
    ///    underscores, and dashes. All characters must use UTF-8 encoding, and
    ///    international characters are allowed.
    /// * The key portion of a label must be unique. However, you can use the same
    ///    key with multiple resources.
    /// * Keys must start with a lowercase letter or international character.
    ///
    /// See [Google Cloud
    /// Document](<https://cloud.google.com/resource-manager/docs/creating-managing-labels#requirements>)
    /// for more details.
    #[prost(btree_map = "string, string", tag = "22")]
    pub user_labels: ::prost::alloc::collections::BTreeMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// If `naturalLanguageQueryUnderstandingSpec` is not specified, no additional
    /// natural language query understanding will be done.
    #[prost(message, optional, tag = "28")]
    pub natural_language_query_understanding_spec: ::core::option::Option<
        search_request::NaturalLanguageQueryUnderstandingSpec,
    >,
    /// Search as you type configuration. Only supported for the
    /// [IndustryVertical.MEDIA][google.cloud.discoveryengine.v1alpha.IndustryVertical.MEDIA]
    /// vertical.
    #[prost(message, optional, tag = "31")]
    pub search_as_you_type_spec: ::core::option::Option<
        search_request::SearchAsYouTypeSpec,
    >,
    /// Custom fine tuning configs.
    /// If set, it has higher priority than the configs set in
    /// [ServingConfig.custom_fine_tuning_spec][google.cloud.discoveryengine.v1alpha.ServingConfig.custom_fine_tuning_spec].
    #[prost(message, optional, tag = "34")]
    pub custom_fine_tuning_spec: ::core::option::Option<CustomFineTuningSpec>,
    /// The session resource name. Optional.
    ///
    /// Session allows users to do multi-turn /search API calls or coordination
    /// between /search API calls and /answer API calls.
    ///
    /// Example #1 (multi-turn /search API calls):
    ///    1. Call /search API with the auto-session mode (see below).
    ///    2. Call /search API with the session ID generated in the first call.
    ///       Here, the previous search query gets considered in query
    ///       standing. I.e., if the first query is "How did Alphabet do in 2022?"
    ///       and the current query is "How about 2023?", the current query will
    ///       be interpreted as "How did Alphabet do in 2023?".
    ///
    /// Example #2 (coordination between /search API calls and /answer API calls):
    ///    1. Call /search API with the auto-session mode (see below).
    ///    2. Call /answer API with the session ID generated in the first call.
    ///       Here, the answer generation happens in the context of the search
    ///       results from the first search call.
    ///
    /// Auto-session mode: when `projects/.../sessions/-` is used, a new session
    /// gets automatically created. Otherwise, users can use the create-session API
    /// to create a session manually.
    ///
    /// Multi-turn Search feature is currently at private GA stage. Please use
    /// v1alpha or v1beta version instead before we launch this feature to public
    /// GA. Or ask for allowlisting through Google Support team.
    #[prost(string, tag = "41")]
    pub session: ::prost::alloc::string::String,
    /// Session specification.
    ///
    /// Can be used only when `session` is set.
    #[prost(message, optional, tag = "42")]
    pub session_spec: ::core::option::Option<search_request::SessionSpec>,
    /// The relevance threshold of the search results.
    ///
    /// Default to Google defined threshold, leveraging a balance of
    /// precision and recall to deliver both highly accurate results and
    /// comprehensive coverage of relevant information.
    #[prost(enumeration = "search_request::RelevanceThreshold", tag = "44")]
    pub relevance_threshold: i32,
}
/// Nested message and enum types in `SearchRequest`.
pub mod search_request {
    /// Specifies the image query input.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ImageQuery {
        #[prost(oneof = "image_query::Image", tags = "1")]
        pub image: ::core::option::Option<image_query::Image>,
    }
    /// Nested message and enum types in `ImageQuery`.
    pub mod image_query {
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum Image {
            /// Base64 encoded image bytes. Supported image formats: JPEG, PNG, and
            /// BMP.
            #[prost(string, tag = "1")]
            ImageBytes(::prost::alloc::string::String),
        }
    }
    /// A struct to define data stores to filter on in a search call and
    /// configurations for those data stores. Otherwise, an `INVALID_ARGUMENT`
    /// error is returned.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct DataStoreSpec {
        /// Required. Full resource name of
        /// [DataStore][google.cloud.discoveryengine.v1alpha.DataStore], such as
        /// `projects/{project}/locations/{location}/collections/{collection_id}/dataStores/{data_store_id}`.
        #[prost(string, tag = "1")]
        pub data_store: ::prost::alloc::string::String,
    }
    /// A facet specification to perform faceted search.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct FacetSpec {
        /// Required. The facet key specification.
        #[prost(message, optional, tag = "1")]
        pub facet_key: ::core::option::Option<facet_spec::FacetKey>,
        /// Maximum facet values that are returned for this facet. If
        /// unspecified, defaults to 20. The maximum allowed value is 300. Values
        /// above 300 are coerced to 300.
        /// For aggregation in healthcare search, when the \[FacetKey.key\] is
        /// "healthcare_aggregation_key", the limit will be overridden to
        /// 10,000 internally, regardless of the value set here.
        ///
        /// If this field is negative, an  `INVALID_ARGUMENT`  is returned.
        #[prost(int32, tag = "2")]
        pub limit: i32,
        /// List of keys to exclude when faceting.
        ///
        ///
        /// By default,
        /// [FacetKey.key][google.cloud.discoveryengine.v1alpha.SearchRequest.FacetSpec.FacetKey.key]
        /// is not excluded from the filter unless it is listed in this field.
        ///
        /// Listing a facet key in this field allows its values to appear as facet
        /// results, even when they are filtered out of search results. Using this
        /// field does not affect what search results are returned.
        ///
        /// For example, suppose there are 100 documents with the color facet "Red"
        /// and 200 documents with the color facet "Blue". A query containing the
        /// filter "color:ANY("Red")" and having "color" as
        /// [FacetKey.key][google.cloud.discoveryengine.v1alpha.SearchRequest.FacetSpec.FacetKey.key]
        /// would by default return only "Red" documents in the search results, and
        /// also return "Red" with count 100 as the only color facet. Although there
        /// are also blue documents available, "Blue" would not be shown as an
        /// available facet value.
        ///
        /// If "color" is listed in "excludedFilterKeys", then the query returns the
        /// facet values "Red" with count 100 and "Blue" with count 200, because the
        /// "color" key is now excluded from the filter. Because this field doesn't
        /// affect search results, the search results are still correctly filtered to
        /// return only "Red" documents.
        ///
        /// A maximum of 100 values are allowed. Otherwise, an  `INVALID_ARGUMENT`
        /// error is returned.
        #[prost(string, repeated, tag = "3")]
        pub excluded_filter_keys: ::prost::alloc::vec::Vec<
            ::prost::alloc::string::String,
        >,
        /// Enables dynamic position for this facet. If set to true, the position of
        /// this facet among all facets in the response is determined automatically.
        /// If dynamic facets are enabled, it is ordered together.
        /// If set to false, the position of this facet in the
        /// response is the same as in the request, and it is ranked before
        /// the facets with dynamic position enable and all dynamic facets.
        ///
        /// For example, you may always want to have rating facet returned in
        /// the response, but it's not necessarily to always display the rating facet
        /// at the top. In that case, you can set enable_dynamic_position to true so
        /// that the position of rating facet in response is determined
        /// automatically.
        ///
        /// Another example, assuming you have the following facets in the request:
        ///
        /// * "rating", enable_dynamic_position = true
        ///
        /// * "price", enable_dynamic_position = false
        ///
        /// * "brands", enable_dynamic_position = false
        ///
        /// And also you have a dynamic facets enabled, which generates a facet
        /// `gender`. Then the final order of the facets in the response can be
        /// ("price", "brands", "rating", "gender") or ("price", "brands", "gender",
        /// "rating") depends on how API orders "gender" and "rating" facets.
        /// However, notice that "price" and "brands" are always
        /// ranked at first and second position because their enable_dynamic_position
        /// is false.
        #[prost(bool, tag = "4")]
        pub enable_dynamic_position: bool,
    }
    /// Nested message and enum types in `FacetSpec`.
    pub mod facet_spec {
        /// Specifies how a facet is computed.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct FacetKey {
            /// Required. Supported textual and numerical facet keys in
            /// [Document][google.cloud.discoveryengine.v1alpha.Document] object, over
            /// which the facet values are computed. Facet key is case-sensitive.
            #[prost(string, tag = "1")]
            pub key: ::prost::alloc::string::String,
            /// Set only if values should be bucketed into intervals. Must be set
            /// for facets with numerical values. Must not be set for facet with text
            /// values. Maximum number of intervals is 30.
            #[prost(message, repeated, tag = "2")]
            pub intervals: ::prost::alloc::vec::Vec<super::super::Interval>,
            /// Only get facet for the given restricted values. Only supported on
            /// textual fields. For example, suppose "category" has three values
            /// "Action > 2022", "Action > 2021" and "Sci-Fi > 2022". If set
            /// "restricted_values" to "Action > 2022", the "category" facet only
            /// contains "Action > 2022". Only supported on textual fields. Maximum
            /// is 10.
            #[prost(string, repeated, tag = "3")]
            pub restricted_values: ::prost::alloc::vec::Vec<
                ::prost::alloc::string::String,
            >,
            /// Only get facet values that start with the given string prefix. For
            /// example, suppose "category" has three values "Action > 2022",
            /// "Action > 2021" and "Sci-Fi > 2022". If set "prefixes" to "Action", the
            /// "category" facet only contains "Action > 2022" and "Action > 2021".
            /// Only supported on textual fields. Maximum is 10.
            #[prost(string, repeated, tag = "4")]
            pub prefixes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
            /// Only get facet values that contain the given strings. For example,
            /// suppose "category" has three values "Action > 2022",
            /// "Action > 2021" and "Sci-Fi > 2022". If set "contains" to "2022", the
            /// "category" facet only contains "Action > 2022" and "Sci-Fi > 2022".
            /// Only supported on textual fields. Maximum is 10.
            #[prost(string, repeated, tag = "5")]
            pub contains: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
            /// True to make facet keys case insensitive when getting faceting
            /// values with prefixes or contains; false otherwise.
            #[prost(bool, tag = "6")]
            pub case_insensitive: bool,
            /// The order in which documents are returned.
            ///
            /// Allowed values are:
            ///
            /// * "count desc", which means order by
            /// [SearchResponse.Facet.values.count][google.cloud.discoveryengine.v1alpha.SearchResponse.Facet.FacetValue.count]
            /// descending.
            ///
            /// * "value desc", which means order by
            /// [SearchResponse.Facet.values.value][google.cloud.discoveryengine.v1alpha.SearchResponse.Facet.FacetValue.value]
            /// descending.
            ///    Only applies to textual facets.
            ///
            /// If not set, textual values are sorted in [natural
            /// order](<https://en.wikipedia.org/wiki/Natural_sort_order>); numerical
            /// intervals are sorted in the order given by
            /// [FacetSpec.FacetKey.intervals][google.cloud.discoveryengine.v1alpha.SearchRequest.FacetSpec.FacetKey.intervals].
            #[prost(string, tag = "7")]
            pub order_by: ::prost::alloc::string::String,
        }
    }
    /// Boost specification to boost certain documents.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct BoostSpec {
        /// Condition boost specifications. If a document matches multiple conditions
        /// in the specifictions, boost scores from these specifications are all
        /// applied and combined in a non-linear way. Maximum number of
        /// specifications is 20.
        #[prost(message, repeated, tag = "1")]
        pub condition_boost_specs: ::prost::alloc::vec::Vec<
            boost_spec::ConditionBoostSpec,
        >,
    }
    /// Nested message and enum types in `BoostSpec`.
    pub mod boost_spec {
        /// Boost applies to documents which match a condition.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct ConditionBoostSpec {
            /// An expression which specifies a boost condition. The syntax and
            /// supported fields are the same as a filter expression. See
            /// [SearchRequest.filter][google.cloud.discoveryengine.v1alpha.SearchRequest.filter]
            /// for detail syntax and limitations.
            ///
            /// Examples:
            ///
            /// * To boost documents with document ID "doc_1" or "doc_2", and
            /// color "Red" or "Blue":
            /// `(document_id: ANY("doc_1", "doc_2")) AND (color: ANY("Red", "Blue"))`
            #[prost(string, tag = "1")]
            pub condition: ::prost::alloc::string::String,
            /// Strength of the condition boost, which should be in \[-1, 1\]. Negative
            /// boost means demotion. Default is 0.0.
            ///
            /// Setting to 1.0 gives the document a big promotion. However, it does
            /// not necessarily mean that the boosted document will be the top result
            /// at all times, nor that other documents will be excluded. Results
            /// could still be shown even when none of them matches the condition.
            /// And results that are significantly more relevant to the search query
            /// can still trump your heavily favored but irrelevant documents.
            ///
            /// Setting to -1.0 gives the document a big demotion. However, results
            /// that are deeply relevant might still be shown. The document will have
            /// an upstream battle to get a fairly high ranking, but it is not
            /// blocked out completely.
            ///
            /// Setting to 0.0 means no boost applied. The boosting condition is
            /// ignored. Only one of the (condition, boost) combination or the
            /// boost_control_spec below are set. If both are set then the global boost
            /// is ignored and the more fine-grained boost_control_spec is applied.
            #[prost(float, tag = "2")]
            pub boost: f32,
            /// Complex specification for custom ranking based on customer defined
            /// attribute value.
            #[prost(message, optional, tag = "3")]
            pub boost_control_spec: ::core::option::Option<
                condition_boost_spec::BoostControlSpec,
            >,
        }
        /// Nested message and enum types in `ConditionBoostSpec`.
        pub mod condition_boost_spec {
            /// Specification for custom ranking based on customer specified attribute
            /// value. It provides more controls for customized ranking than the simple
            /// (condition, boost) combination above.
            #[derive(Clone, PartialEq, ::prost::Message)]
            pub struct BoostControlSpec {
                /// The name of the field whose value will be used to determine the
                /// boost amount.
                #[prost(string, tag = "1")]
                pub field_name: ::prost::alloc::string::String,
                /// The attribute type to be used to determine the boost amount. The
                /// attribute value can be derived from the field value of the specified
                /// field_name. In the case of numerical it is straightforward i.e.
                /// attribute_value = numerical_field_value. In the case of freshness
                /// however, attribute_value = (time.now() - datetime_field_value).
                #[prost(enumeration = "boost_control_spec::AttributeType", tag = "2")]
                pub attribute_type: i32,
                /// The interpolation type to be applied to connect the control points
                /// listed below.
                #[prost(
                    enumeration = "boost_control_spec::InterpolationType",
                    tag = "3"
                )]
                pub interpolation_type: i32,
                /// The control points used to define the curve. The monotonic function
                /// (defined through the interpolation_type above) passes through the
                /// control points listed here.
                #[prost(message, repeated, tag = "4")]
                pub control_points: ::prost::alloc::vec::Vec<
                    boost_control_spec::ControlPoint,
                >,
            }
            /// Nested message and enum types in `BoostControlSpec`.
            pub mod boost_control_spec {
                /// The control points used to define the curve. The curve defined
                /// through these control points can only be monotonically increasing
                /// or decreasing(constant values are acceptable).
                #[derive(Clone, PartialEq, ::prost::Message)]
                pub struct ControlPoint {
                    /// Can be one of:
                    /// 1. The numerical field value.
                    /// 2. The duration spec for freshness:
                    /// The value must be formatted as an XSD `dayTimeDuration` value (a
                    /// restricted subset of an ISO 8601 duration value). The pattern for
                    /// this is: `[nD][T[nH][nM][nS]]`.
                    #[prost(string, tag = "1")]
                    pub attribute_value: ::prost::alloc::string::String,
                    /// The value between -1 to 1 by which to boost the score if the
                    /// attribute_value evaluates to the value specified above.
                    #[prost(float, tag = "2")]
                    pub boost_amount: f32,
                }
                /// The attribute(or function) for which the custom ranking is to be
                /// applied.
                #[derive(
                    Clone,
                    Copy,
                    Debug,
                    PartialEq,
                    Eq,
                    Hash,
                    PartialOrd,
                    Ord,
                    ::prost::Enumeration
                )]
                #[repr(i32)]
                pub enum AttributeType {
                    /// Unspecified AttributeType.
                    Unspecified = 0,
                    /// The value of the numerical field will be used to dynamically update
                    /// the boost amount. In this case, the attribute_value (the x value)
                    /// of the control point will be the actual value of the numerical
                    /// field for which the boost_amount is specified.
                    Numerical = 1,
                    /// For the freshness use case the attribute value will be the duration
                    /// between the current time and the date in the datetime field
                    /// specified. The value must be formatted as an XSD `dayTimeDuration`
                    /// value (a restricted subset of an ISO 8601 duration value). The
                    /// pattern for this is: `[nD][T[nH][nM][nS]]`.
                    /// For example, `5D`, `3DT12H30M`, `T24H`.
                    Freshness = 2,
                }
                impl AttributeType {
                    /// 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 {
                            AttributeType::Unspecified => "ATTRIBUTE_TYPE_UNSPECIFIED",
                            AttributeType::Numerical => "NUMERICAL",
                            AttributeType::Freshness => "FRESHNESS",
                        }
                    }
                    /// Creates an enum from field names used in the ProtoBuf definition.
                    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                        match value {
                            "ATTRIBUTE_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                            "NUMERICAL" => Some(Self::Numerical),
                            "FRESHNESS" => Some(Self::Freshness),
                            _ => None,
                        }
                    }
                }
                /// The interpolation type to be applied. Default will be linear
                /// (Piecewise Linear).
                #[derive(
                    Clone,
                    Copy,
                    Debug,
                    PartialEq,
                    Eq,
                    Hash,
                    PartialOrd,
                    Ord,
                    ::prost::Enumeration
                )]
                #[repr(i32)]
                pub enum InterpolationType {
                    /// Interpolation type is unspecified. In this case, it defaults to
                    /// Linear.
                    Unspecified = 0,
                    /// Piecewise linear interpolation will be applied.
                    Linear = 1,
                }
                impl InterpolationType {
                    /// 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 {
                            InterpolationType::Unspecified => {
                                "INTERPOLATION_TYPE_UNSPECIFIED"
                            }
                            InterpolationType::Linear => "LINEAR",
                        }
                    }
                    /// Creates an enum from field names used in the ProtoBuf definition.
                    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                        match value {
                            "INTERPOLATION_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                            "LINEAR" => Some(Self::Linear),
                            _ => None,
                        }
                    }
                }
            }
        }
    }
    /// Specification to determine under which conditions query expansion should
    /// occur.
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct QueryExpansionSpec {
        /// The condition under which query expansion should occur. Default to
        /// [Condition.DISABLED][google.cloud.discoveryengine.v1alpha.SearchRequest.QueryExpansionSpec.Condition.DISABLED].
        #[prost(enumeration = "query_expansion_spec::Condition", tag = "1")]
        pub condition: i32,
        /// Whether to pin unexpanded results. If this field is set to true,
        /// unexpanded products are always at the top of the search results, followed
        /// by the expanded results.
        #[prost(bool, tag = "2")]
        pub pin_unexpanded_results: bool,
    }
    /// Nested message and enum types in `QueryExpansionSpec`.
    pub mod query_expansion_spec {
        /// Enum describing under which condition query expansion should occur.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum Condition {
            /// Unspecified query expansion condition. In this case, server behavior
            /// defaults to
            /// [Condition.DISABLED][google.cloud.discoveryengine.v1alpha.SearchRequest.QueryExpansionSpec.Condition.DISABLED].
            Unspecified = 0,
            /// Disabled query expansion. Only the exact search query is used, even if
            /// [SearchResponse.total_size][google.cloud.discoveryengine.v1alpha.SearchResponse.total_size]
            /// is zero.
            Disabled = 1,
            /// Automatic query expansion built by the Search API.
            Auto = 2,
        }
        impl Condition {
            /// 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 {
                    Condition::Unspecified => "CONDITION_UNSPECIFIED",
                    Condition::Disabled => "DISABLED",
                    Condition::Auto => "AUTO",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "CONDITION_UNSPECIFIED" => Some(Self::Unspecified),
                    "DISABLED" => Some(Self::Disabled),
                    "AUTO" => Some(Self::Auto),
                    _ => None,
                }
            }
        }
    }
    /// The specification for query spell correction.
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct SpellCorrectionSpec {
        /// The mode under which spell correction
        /// replaces the original search query. Defaults to
        /// [Mode.AUTO][google.cloud.discoveryengine.v1alpha.SearchRequest.SpellCorrectionSpec.Mode.AUTO].
        #[prost(enumeration = "spell_correction_spec::Mode", tag = "1")]
        pub mode: i32,
    }
    /// Nested message and enum types in `SpellCorrectionSpec`.
    pub mod spell_correction_spec {
        /// Enum describing under which mode spell correction should occur.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum Mode {
            /// Unspecified spell correction mode. In this case, server behavior
            /// defaults to
            /// [Mode.AUTO][google.cloud.discoveryengine.v1alpha.SearchRequest.SpellCorrectionSpec.Mode.AUTO].
            Unspecified = 0,
            /// Search API tries to find a spelling suggestion. If a suggestion is
            /// found, it is put in the
            /// [SearchResponse.corrected_query][google.cloud.discoveryengine.v1alpha.SearchResponse.corrected_query].
            /// The spelling suggestion won't be used as the search query.
            SuggestionOnly = 1,
            /// Automatic spell correction built by the Search API. Search will
            /// be based on the corrected query if found.
            Auto = 2,
        }
        impl Mode {
            /// 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 {
                    Mode::Unspecified => "MODE_UNSPECIFIED",
                    Mode::SuggestionOnly => "SUGGESTION_ONLY",
                    Mode::Auto => "AUTO",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "MODE_UNSPECIFIED" => Some(Self::Unspecified),
                    "SUGGESTION_ONLY" => Some(Self::SuggestionOnly),
                    "AUTO" => Some(Self::Auto),
                    _ => None,
                }
            }
        }
    }
    /// A specification for configuring the behavior of content search.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ContentSearchSpec {
        /// If `snippetSpec` is not specified, snippets are not included in the
        /// search response.
        #[prost(message, optional, tag = "1")]
        pub snippet_spec: ::core::option::Option<content_search_spec::SnippetSpec>,
        /// If `summarySpec` is not specified, summaries are not included in the
        /// search response.
        #[prost(message, optional, tag = "2")]
        pub summary_spec: ::core::option::Option<content_search_spec::SummarySpec>,
        /// If there is no extractive_content_spec provided, there will be no
        /// extractive answer in the search response.
        #[prost(message, optional, tag = "3")]
        pub extractive_content_spec: ::core::option::Option<
            content_search_spec::ExtractiveContentSpec,
        >,
        /// Specifies the search result mode. If unspecified, the
        /// search result mode defaults to `DOCUMENTS`.
        #[prost(enumeration = "content_search_spec::SearchResultMode", tag = "4")]
        pub search_result_mode: i32,
        /// Specifies the chunk spec to be returned from the search response.
        /// Only available if the
        /// [SearchRequest.ContentSearchSpec.search_result_mode][google.cloud.discoveryengine.v1alpha.SearchRequest.ContentSearchSpec.search_result_mode]
        /// is set to
        /// [CHUNKS][google.cloud.discoveryengine.v1alpha.SearchRequest.ContentSearchSpec.SearchResultMode.CHUNKS]
        #[prost(message, optional, tag = "5")]
        pub chunk_spec: ::core::option::Option<content_search_spec::ChunkSpec>,
    }
    /// Nested message and enum types in `ContentSearchSpec`.
    pub mod content_search_spec {
        /// A specification for configuring snippets in a search response.
        #[derive(Clone, Copy, PartialEq, ::prost::Message)]
        pub struct SnippetSpec {
            /// \[DEPRECATED\] This field is deprecated. To control snippet return, use
            /// `return_snippet` field. For backwards compatibility, we will return
            /// snippet if max_snippet_count > 0.
            #[deprecated]
            #[prost(int32, tag = "1")]
            pub max_snippet_count: i32,
            /// \[DEPRECATED\] This field is deprecated and will have no affect on the
            /// snippet.
            #[deprecated]
            #[prost(bool, tag = "2")]
            pub reference_only: bool,
            /// If `true`, then return snippet. If no snippet can be generated, we
            /// return "No snippet is available for this page." A `snippet_status` with
            /// `SUCCESS` or `NO_SNIPPET_AVAILABLE` will also be returned.
            #[prost(bool, tag = "3")]
            pub return_snippet: bool,
        }
        /// A specification for configuring a summary returned in a search
        /// response.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct SummarySpec {
            /// The number of top results to generate the summary from. If the number
            /// of results returned is less than `summaryResultCount`, the summary is
            /// generated from all of the results.
            ///
            /// At most 10 results for documents mode, or 50 for chunks mode, can be
            /// used to generate a summary. The chunks mode is used when
            /// [SearchRequest.ContentSearchSpec.search_result_mode][google.cloud.discoveryengine.v1alpha.SearchRequest.ContentSearchSpec.search_result_mode]
            /// is set to
            /// [CHUNKS][google.cloud.discoveryengine.v1alpha.SearchRequest.ContentSearchSpec.SearchResultMode.CHUNKS].
            #[prost(int32, tag = "1")]
            pub summary_result_count: i32,
            /// Specifies whether to include citations in the summary. The default
            /// value is `false`.
            ///
            /// When this field is set to `true`, summaries include in-line citation
            /// numbers.
            ///
            /// Example summary including citations:
            ///
            /// BigQuery is Google Cloud's fully managed and completely serverless
            /// enterprise data warehouse \[1\]. BigQuery supports all data types, works
            /// across clouds, and has built-in machine learning and business
            /// intelligence, all within a unified platform \[2, 3\].
            ///
            /// The citation numbers refer to the returned search results and are
            /// 1-indexed. For example, \[1\] means that the sentence is attributed to
            /// the first search result. \[2, 3\] means that the sentence is attributed
            /// to both the second and third search results.
            #[prost(bool, tag = "2")]
            pub include_citations: bool,
            /// Specifies whether to filter out adversarial queries. The default value
            /// is `false`.
            ///
            /// Google employs search-query classification to detect adversarial
            /// queries. No summary is returned if the search query is classified as an
            /// adversarial query. For example, a user might ask a question regarding
            /// negative comments about the company or submit a query designed to
            /// generate unsafe, policy-violating output. If this field is set to
            /// `true`, we skip generating summaries for adversarial queries and return
            /// fallback messages instead.
            #[prost(bool, tag = "3")]
            pub ignore_adversarial_query: bool,
            /// Specifies whether to filter out queries that are not summary-seeking.
            /// The default value is `false`.
            ///
            /// Google employs search-query classification to detect summary-seeking
            /// queries. No summary is returned if the search query is classified as a
            /// non-summary seeking query. For example, `why is the sky blue` and `Who
            /// is the best soccer player in the world?` are summary-seeking queries,
            /// but `SFO airport` and `world cup 2026` are not. They are most likely
            /// navigational queries. If this field is set to `true`, we skip
            /// generating summaries for non-summary seeking queries and return
            /// fallback messages instead.
            #[prost(bool, tag = "4")]
            pub ignore_non_summary_seeking_query: bool,
            /// Specifies whether to filter out queries that have low relevance. The
            /// default value is `false`.
            ///
            /// If this field is set to `false`, all search results are used regardless
            /// of relevance to generate answers. If set to `true`, only queries with
            /// high relevance search results will generate answers.
            #[prost(bool, tag = "9")]
            pub ignore_low_relevant_content: bool,
            /// If specified, the spec will be used to modify the prompt provided to
            /// the LLM.
            #[prost(message, optional, tag = "5")]
            pub model_prompt_spec: ::core::option::Option<summary_spec::ModelPromptSpec>,
            /// Language code for Summary. Use language tags defined by
            /// [BCP47](<https://www.rfc-editor.org/rfc/bcp/bcp47.txt>).
            /// Note: This is an experimental feature.
            #[prost(string, tag = "6")]
            pub language_code: ::prost::alloc::string::String,
            /// If specified, the spec will be used to modify the model specification
            /// provided to the LLM.
            #[prost(message, optional, tag = "7")]
            pub model_spec: ::core::option::Option<summary_spec::ModelSpec>,
            /// If true, answer will be generated from most relevant chunks from top
            /// search results. This feature will improve summary quality.
            /// Note that with this feature enabled, not all top search results
            /// will be referenced and included in the reference list, so the citation
            /// source index only points to the search results listed in the reference
            /// list.
            #[prost(bool, tag = "8")]
            pub use_semantic_chunks: bool,
        }
        /// Nested message and enum types in `SummarySpec`.
        pub mod summary_spec {
            /// Specification of the prompt to use with the model.
            #[derive(Clone, PartialEq, ::prost::Message)]
            pub struct ModelPromptSpec {
                /// Text at the beginning of the prompt that instructs the assistant.
                /// Examples are available in the user guide.
                #[prost(string, tag = "1")]
                pub preamble: ::prost::alloc::string::String,
            }
            /// Specification of the model.
            #[derive(Clone, PartialEq, ::prost::Message)]
            pub struct ModelSpec {
                /// The model version used to generate the summary.
                ///
                /// Supported values are:
                ///
                /// * `stable`: string. Default value when no value is specified. Uses a
                ///     generally available, fine-tuned model. For more information, see
                ///     [Answer generation model versions and
                ///     lifecycle](<https://cloud.google.com/generative-ai-app-builder/docs/answer-generation-models>).
                /// * `preview`: string. (Public preview) Uses a preview model. For more
                ///     information, see
                ///     [Answer generation model versions and
                ///     lifecycle](<https://cloud.google.com/generative-ai-app-builder/docs/answer-generation-models>).
                #[prost(string, tag = "1")]
                pub version: ::prost::alloc::string::String,
            }
        }
        /// A specification for configuring the extractive content in a search
        /// response.
        #[derive(Clone, Copy, PartialEq, ::prost::Message)]
        pub struct ExtractiveContentSpec {
            /// The maximum number of extractive answers returned in each search
            /// result.
            ///
            /// An extractive answer is a verbatim answer extracted from the original
            /// document, which provides a precise and contextually relevant answer to
            /// the search query.
            ///
            /// If the number of matching answers is less than the
            /// `max_extractive_answer_count`, return all of the answers. Otherwise,
            /// return the `max_extractive_answer_count`.
            ///
            /// At most five answers are returned for each
            /// [SearchResult][google.cloud.discoveryengine.v1alpha.SearchResponse.SearchResult].
            #[prost(int32, tag = "1")]
            pub max_extractive_answer_count: i32,
            /// The max number of extractive segments returned in each search result.
            /// Only applied if the
            /// [DataStore][google.cloud.discoveryengine.v1alpha.DataStore] is set to
            /// [DataStore.ContentConfig.CONTENT_REQUIRED][google.cloud.discoveryengine.v1alpha.DataStore.ContentConfig.CONTENT_REQUIRED]
            /// or
            /// [DataStore.solution_types][google.cloud.discoveryengine.v1alpha.DataStore.solution_types]
            /// is
            /// [SOLUTION_TYPE_CHAT][google.cloud.discoveryengine.v1alpha.SolutionType.SOLUTION_TYPE_CHAT].
            ///
            /// An extractive segment is a text segment extracted from the original
            /// document that is relevant to the search query, and, in general, more
            /// verbose than an extractive answer. The segment could then be used as
            /// input for LLMs to generate summaries and answers.
            ///
            /// If the number of matching segments is less than
            /// `max_extractive_segment_count`, return all of the segments. Otherwise,
            /// return the `max_extractive_segment_count`.
            #[prost(int32, tag = "2")]
            pub max_extractive_segment_count: i32,
            /// Specifies whether to return the confidence score from the extractive
            /// segments in each search result. This feature is available only for new
            /// or allowlisted data stores. To allowlist your data store,
            /// contact your Customer Engineer. The default value is `false`.
            #[prost(bool, tag = "3")]
            pub return_extractive_segment_score: bool,
            /// Specifies whether to also include the adjacent from each selected
            /// segments.
            /// Return at most `num_previous_segments` segments before each selected
            /// segments.
            #[prost(int32, tag = "4")]
            pub num_previous_segments: i32,
            /// Return at most `num_next_segments` segments after each selected
            /// segments.
            #[prost(int32, tag = "5")]
            pub num_next_segments: i32,
        }
        /// Specifies the chunk spec to be returned from the search response.
        /// Only available if the
        /// [SearchRequest.ContentSearchSpec.search_result_mode][google.cloud.discoveryengine.v1alpha.SearchRequest.ContentSearchSpec.search_result_mode]
        /// is set to
        /// [CHUNKS][google.cloud.discoveryengine.v1alpha.SearchRequest.ContentSearchSpec.SearchResultMode.CHUNKS]
        #[derive(Clone, Copy, PartialEq, ::prost::Message)]
        pub struct ChunkSpec {
            /// The number of previous chunks to be returned of the current chunk. The
            /// maximum allowed value is 3.
            /// If not specified, no previous chunks will be returned.
            #[prost(int32, tag = "1")]
            pub num_previous_chunks: i32,
            /// The number of next chunks to be returned of the current chunk. The
            /// maximum allowed value is 3.
            /// If not specified, no next chunks will be returned.
            #[prost(int32, tag = "2")]
            pub num_next_chunks: i32,
        }
        /// Specifies the search result mode. If unspecified, the
        /// search result mode defaults to `DOCUMENTS`.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum SearchResultMode {
            /// Default value.
            Unspecified = 0,
            /// Returns documents in the search result.
            Documents = 1,
            /// Returns chunks in the search result. Only available if the
            /// [DataStore.DocumentProcessingConfig.chunking_config][] is specified.
            Chunks = 2,
        }
        impl SearchResultMode {
            /// 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 {
                    SearchResultMode::Unspecified => "SEARCH_RESULT_MODE_UNSPECIFIED",
                    SearchResultMode::Documents => "DOCUMENTS",
                    SearchResultMode::Chunks => "CHUNKS",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "SEARCH_RESULT_MODE_UNSPECIFIED" => Some(Self::Unspecified),
                    "DOCUMENTS" => Some(Self::Documents),
                    "CHUNKS" => Some(Self::Chunks),
                    _ => None,
                }
            }
        }
    }
    /// The specification that uses customized query embedding vector to do
    /// semantic document retrieval.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct EmbeddingSpec {
        /// The embedding vector used for retrieval. Limit to 1.
        #[prost(message, repeated, tag = "1")]
        pub embedding_vectors: ::prost::alloc::vec::Vec<embedding_spec::EmbeddingVector>,
    }
    /// Nested message and enum types in `EmbeddingSpec`.
    pub mod embedding_spec {
        /// Embedding vector.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct EmbeddingVector {
            /// Embedding field path in schema.
            #[prost(string, tag = "1")]
            pub field_path: ::prost::alloc::string::String,
            /// Query embedding vector.
            #[prost(float, repeated, tag = "2")]
            pub vector: ::prost::alloc::vec::Vec<f32>,
        }
    }
    /// Specification to enable natural language understanding capabilities for
    /// search requests.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct NaturalLanguageQueryUnderstandingSpec {
        /// The condition under which filter extraction should occur.
        /// Default to [Condition.DISABLED][].
        #[prost(
            enumeration = "natural_language_query_understanding_spec::FilterExtractionCondition",
            tag = "1"
        )]
        pub filter_extraction_condition: i32,
        /// Field names used for location-based filtering, where geolocation filters
        /// are detected in natural language search queries.
        /// Only valid when the FilterExtractionCondition is set to `ENABLED`.
        ///
        /// If this field is set, it overrides the field names set in
        /// [ServingConfig.geo_search_query_detection_field_names][google.cloud.discoveryengine.v1alpha.ServingConfig.geo_search_query_detection_field_names].
        #[prost(string, repeated, tag = "2")]
        pub geo_search_query_detection_field_names: ::prost::alloc::vec::Vec<
            ::prost::alloc::string::String,
        >,
    }
    /// Nested message and enum types in `NaturalLanguageQueryUnderstandingSpec`.
    pub mod natural_language_query_understanding_spec {
        /// Enum describing under which condition filter extraction should occur.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum FilterExtractionCondition {
            /// Server behavior defaults to [Condition.DISABLED][].
            ConditionUnspecified = 0,
            /// Disables NL filter extraction.
            Disabled = 1,
            /// Enables NL filter extraction.
            Enabled = 2,
        }
        impl FilterExtractionCondition {
            /// 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 {
                    FilterExtractionCondition::ConditionUnspecified => {
                        "CONDITION_UNSPECIFIED"
                    }
                    FilterExtractionCondition::Disabled => "DISABLED",
                    FilterExtractionCondition::Enabled => "ENABLED",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "CONDITION_UNSPECIFIED" => Some(Self::ConditionUnspecified),
                    "DISABLED" => Some(Self::Disabled),
                    "ENABLED" => Some(Self::Enabled),
                    _ => None,
                }
            }
        }
    }
    /// Specification for search as you type in search requests.
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct SearchAsYouTypeSpec {
        /// The condition under which search as you type should occur.
        /// Default to
        /// [Condition.DISABLED][google.cloud.discoveryengine.v1alpha.SearchRequest.SearchAsYouTypeSpec.Condition.DISABLED].
        #[prost(enumeration = "search_as_you_type_spec::Condition", tag = "1")]
        pub condition: i32,
    }
    /// Nested message and enum types in `SearchAsYouTypeSpec`.
    pub mod search_as_you_type_spec {
        /// Enum describing under which condition search as you type should occur.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum Condition {
            /// Server behavior defaults to
            /// [Condition.DISABLED][google.cloud.discoveryengine.v1alpha.SearchRequest.SearchAsYouTypeSpec.Condition.DISABLED].
            Unspecified = 0,
            /// Disables Search As You Type.
            Disabled = 1,
            /// Enables Search As You Type.
            Enabled = 2,
        }
        impl Condition {
            /// 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 {
                    Condition::Unspecified => "CONDITION_UNSPECIFIED",
                    Condition::Disabled => "DISABLED",
                    Condition::Enabled => "ENABLED",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "CONDITION_UNSPECIFIED" => Some(Self::Unspecified),
                    "DISABLED" => Some(Self::Disabled),
                    "ENABLED" => Some(Self::Enabled),
                    _ => None,
                }
            }
        }
    }
    /// Session specification.
    ///
    /// Multi-turn Search feature is currently at private GA stage. Please use
    /// v1alpha or v1beta version instead before we launch this feature to public
    /// GA. Or ask for allowlisting through Google Support team.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct SessionSpec {
        /// If set, the search result gets stored to the "turn" specified by this
        /// query ID.
        ///
        /// Example: Let's say the session looks like this:
        ///    session {
        ///      name: ".../sessions/xxx"
        ///      turns {
        ///        query { text: "What is foo?" query_id: ".../questions/yyy" }
        ///        answer: "Foo is ..."
        ///      }
        ///      turns {
        ///        query { text: "How about bar then?" query_id: ".../questions/zzz" }
        ///      }
        ///    }
        ///
        /// The user can call /search API with a request like this:
        ///
        ///     session: ".../sessions/xxx"
        ///     session_spec { query_id: ".../questions/zzz" }
        ///
        /// Then, the API stores the search result, associated with the last turn.
        /// The stored search result can be used by a subsequent /answer API call
        /// (with the session ID and the query ID specified). Also, it is possible
        /// to call /search and /answer in parallel with the same session ID & query
        /// ID.
        #[prost(string, tag = "1")]
        pub query_id: ::prost::alloc::string::String,
        /// The number of top search results to persist. The persisted search results
        /// can be used for the subsequent /answer api call.
        ///
        /// This field is simliar to the `summary_result_count` field in
        /// [SearchRequest.ContentSearchSpec.SummarySpec.summary_result_count][google.cloud.discoveryengine.v1alpha.SearchRequest.ContentSearchSpec.SummarySpec.summary_result_count].
        ///
        /// At most 10 results for documents mode, or 50 for chunks mode.
        #[prost(int32, optional, tag = "2")]
        pub search_result_persistence_count: ::core::option::Option<i32>,
    }
    /// The relevance threshold of the search results. The higher relevance
    /// threshold is, the higher relevant results are shown and the less number of
    /// results are returned.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum RelevanceThreshold {
        /// Default value. In this case, server behavior defaults to Google defined
        /// threshold.
        Unspecified = 0,
        /// Lowest relevance threshold.
        Lowest = 1,
        /// Low relevance threshold.
        Low = 2,
        /// Medium relevance threshold.
        Medium = 3,
        /// High relevance threshold.
        High = 4,
    }
    impl RelevanceThreshold {
        /// 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 {
                RelevanceThreshold::Unspecified => "RELEVANCE_THRESHOLD_UNSPECIFIED",
                RelevanceThreshold::Lowest => "LOWEST",
                RelevanceThreshold::Low => "LOW",
                RelevanceThreshold::Medium => "MEDIUM",
                RelevanceThreshold::High => "HIGH",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "RELEVANCE_THRESHOLD_UNSPECIFIED" => Some(Self::Unspecified),
                "LOWEST" => Some(Self::Lowest),
                "LOW" => Some(Self::Low),
                "MEDIUM" => Some(Self::Medium),
                "HIGH" => Some(Self::High),
                _ => None,
            }
        }
    }
}
/// Response message for
/// [SearchService.Search][google.cloud.discoveryengine.v1alpha.SearchService.Search]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SearchResponse {
    /// A list of matched documents. The order represents the ranking.
    #[prost(message, repeated, tag = "1")]
    pub results: ::prost::alloc::vec::Vec<search_response::SearchResult>,
    /// Results of facets requested by user.
    #[prost(message, repeated, tag = "2")]
    pub facets: ::prost::alloc::vec::Vec<search_response::Facet>,
    /// Guided search result.
    #[prost(message, optional, tag = "8")]
    pub guided_search_result: ::core::option::Option<
        search_response::GuidedSearchResult,
    >,
    /// The estimated total count of matched items irrespective of pagination. The
    /// count of
    /// [results][google.cloud.discoveryengine.v1alpha.SearchResponse.results]
    /// returned by pagination may be less than the
    /// [total_size][google.cloud.discoveryengine.v1alpha.SearchResponse.total_size]
    /// that matches.
    #[prost(int32, tag = "3")]
    pub total_size: i32,
    /// A unique search token. This should be included in the
    /// [UserEvent][google.cloud.discoveryengine.v1alpha.UserEvent] logs resulting
    /// from this search, which enables accurate attribution of search model
    /// performance. This also helps to identify a request during the customer
    /// support scenarios.
    #[prost(string, tag = "4")]
    pub attribution_token: ::prost::alloc::string::String,
    /// The URI of a customer-defined redirect page. If redirect action is
    /// triggered, no search is performed, and only
    /// [redirect_uri][google.cloud.discoveryengine.v1alpha.SearchResponse.redirect_uri]
    /// and
    /// [attribution_token][google.cloud.discoveryengine.v1alpha.SearchResponse.attribution_token]
    /// are set in the response.
    #[prost(string, tag = "12")]
    pub redirect_uri: ::prost::alloc::string::String,
    /// A token that can be sent as
    /// [SearchRequest.page_token][google.cloud.discoveryengine.v1alpha.SearchRequest.page_token]
    /// to retrieve the next page. If this field is omitted, there are no
    /// subsequent pages.
    #[prost(string, tag = "5")]
    pub next_page_token: ::prost::alloc::string::String,
    /// Contains the spell corrected query, if found. If the spell correction type
    /// is AUTOMATIC, then the search results are based on corrected_query.
    /// Otherwise the original query is used for search.
    #[prost(string, tag = "7")]
    pub corrected_query: ::prost::alloc::string::String,
    /// A summary as part of the search results.
    /// This field is only returned if
    /// [SearchRequest.ContentSearchSpec.summary_spec][google.cloud.discoveryengine.v1alpha.SearchRequest.ContentSearchSpec.summary_spec]
    /// is set.
    #[prost(message, optional, tag = "9")]
    pub summary: ::core::option::Option<search_response::Summary>,
    /// Controls applied as part of the Control service.
    #[prost(string, repeated, tag = "10")]
    pub applied_controls: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(message, repeated, tag = "16")]
    pub geo_search_debug_info: ::prost::alloc::vec::Vec<
        search_response::GeoSearchDebugInfo,
    >,
    /// Query expansion information for the returned results.
    #[prost(message, optional, tag = "14")]
    pub query_expansion_info: ::core::option::Option<
        search_response::QueryExpansionInfo,
    >,
    /// Natural language query understanding information for the returned results.
    #[prost(message, optional, tag = "15")]
    pub natural_language_query_understanding_info: ::core::option::Option<
        search_response::NaturalLanguageQueryUnderstandingInfo,
    >,
    /// Session information.
    ///
    /// Only set if
    /// [SearchRequest.session][google.cloud.discoveryengine.v1alpha.SearchRequest.session]
    /// is provided. See its description for more details.
    #[prost(message, optional, tag = "19")]
    pub session_info: ::core::option::Option<search_response::SessionInfo>,
    /// A list of One Box results. There can be multiple One Box results of
    /// different types.
    #[prost(message, repeated, tag = "20")]
    pub one_box_results: ::prost::alloc::vec::Vec<search_response::OneBoxResult>,
}
/// Nested message and enum types in `SearchResponse`.
pub mod search_response {
    /// Represents the search results.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct SearchResult {
        /// [Document.id][google.cloud.discoveryengine.v1alpha.Document.id] of the
        /// searched [Document][google.cloud.discoveryengine.v1alpha.Document].
        #[prost(string, tag = "1")]
        pub id: ::prost::alloc::string::String,
        /// The document data snippet in the search response. Only fields that are
        /// marked as `retrievable` are populated.
        #[prost(message, optional, tag = "2")]
        pub document: ::core::option::Option<super::Document>,
        /// The chunk data in the search response if the
        /// [SearchRequest.ContentSearchSpec.search_result_mode][google.cloud.discoveryengine.v1alpha.SearchRequest.ContentSearchSpec.search_result_mode]
        /// is set to
        /// [CHUNKS][google.cloud.discoveryengine.v1alpha.SearchRequest.ContentSearchSpec.SearchResultMode.CHUNKS].
        #[prost(message, optional, tag = "18")]
        pub chunk: ::core::option::Option<super::Chunk>,
        /// Google provided available scores.
        #[prost(btree_map = "string, message", tag = "4")]
        pub model_scores: ::prost::alloc::collections::BTreeMap<
            ::prost::alloc::string::String,
            super::DoubleList,
        >,
    }
    /// A facet result.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Facet {
        /// The key for this facet. For example, `"colors"` or `"price"`. It matches
        /// [SearchRequest.FacetSpec.FacetKey.key][google.cloud.discoveryengine.v1alpha.SearchRequest.FacetSpec.FacetKey.key].
        #[prost(string, tag = "1")]
        pub key: ::prost::alloc::string::String,
        /// The facet values for this field.
        #[prost(message, repeated, tag = "2")]
        pub values: ::prost::alloc::vec::Vec<facet::FacetValue>,
        /// Whether the facet is dynamically generated.
        #[prost(bool, tag = "3")]
        pub dynamic_facet: bool,
    }
    /// Nested message and enum types in `Facet`.
    pub mod facet {
        /// A facet value which contains value names and their count.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct FacetValue {
            /// Number of items that have this facet value.
            #[prost(int64, tag = "3")]
            pub count: i64,
            /// A facet value which contains values.
            #[prost(oneof = "facet_value::FacetValue", tags = "1, 2")]
            pub facet_value: ::core::option::Option<facet_value::FacetValue>,
        }
        /// Nested message and enum types in `FacetValue`.
        pub mod facet_value {
            /// A facet value which contains values.
            #[derive(Clone, PartialEq, ::prost::Oneof)]
            pub enum FacetValue {
                /// Text value of a facet, such as "Black" for facet "colors".
                #[prost(string, tag = "1")]
                Value(::prost::alloc::string::String),
                /// Interval value for a facet, such as [10, 20) for facet "price". It
                /// matches
                /// [SearchRequest.FacetSpec.FacetKey.intervals][google.cloud.discoveryengine.v1alpha.SearchRequest.FacetSpec.FacetKey.intervals].
                #[prost(message, tag = "2")]
                Interval(super::super::super::Interval),
            }
        }
    }
    /// Guided search result. The guided search helps user to refine the search
    /// results and narrow down to the real needs from a broaded search results.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct GuidedSearchResult {
        /// A list of ranked refinement attributes.
        #[prost(message, repeated, tag = "1")]
        pub refinement_attributes: ::prost::alloc::vec::Vec<
            guided_search_result::RefinementAttribute,
        >,
        /// Suggested follow-up questions.
        #[prost(string, repeated, tag = "2")]
        pub follow_up_questions: ::prost::alloc::vec::Vec<
            ::prost::alloc::string::String,
        >,
    }
    /// Nested message and enum types in `GuidedSearchResult`.
    pub mod guided_search_result {
        /// Useful attribute for search result refinements.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct RefinementAttribute {
            /// Attribute key used to refine the results. For example, `"movie_type"`.
            #[prost(string, tag = "1")]
            pub attribute_key: ::prost::alloc::string::String,
            /// Attribute value used to refine the results. For example, `"drama"`.
            #[prost(string, tag = "2")]
            pub attribute_value: ::prost::alloc::string::String,
        }
    }
    /// Summary of the top N search results specified by the summary spec.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Summary {
        /// The summary content.
        #[prost(string, tag = "1")]
        pub summary_text: ::prost::alloc::string::String,
        /// Additional summary-skipped reasons. This provides the reason for ignored
        /// cases. If nothing is skipped, this field is not set.
        #[prost(enumeration = "summary::SummarySkippedReason", repeated, tag = "2")]
        pub summary_skipped_reasons: ::prost::alloc::vec::Vec<i32>,
        /// A collection of Safety Attribute categories and their associated
        /// confidence scores.
        #[prost(message, optional, tag = "3")]
        pub safety_attributes: ::core::option::Option<summary::SafetyAttributes>,
        /// Summary with metadata information.
        #[prost(message, optional, tag = "4")]
        pub summary_with_metadata: ::core::option::Option<summary::SummaryWithMetadata>,
    }
    /// Nested message and enum types in `Summary`.
    pub mod summary {
        /// Safety Attribute categories and their associated confidence scores.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct SafetyAttributes {
            /// The display names of Safety Attribute categories associated with the
            /// generated content. Order matches the Scores.
            #[prost(string, repeated, tag = "1")]
            pub categories: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
            /// The confidence scores of the each category, higher
            /// value means higher confidence. Order matches the Categories.
            #[prost(float, repeated, tag = "2")]
            pub scores: ::prost::alloc::vec::Vec<f32>,
        }
        /// Citation metadata.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct CitationMetadata {
            /// Citations for segments.
            #[prost(message, repeated, tag = "1")]
            pub citations: ::prost::alloc::vec::Vec<Citation>,
        }
        /// Citation info for a segment.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct Citation {
            /// Index indicates the start of the segment, measured in bytes/unicode.
            #[prost(int64, tag = "1")]
            pub start_index: i64,
            /// End of the attributed segment, exclusive.
            #[prost(int64, tag = "2")]
            pub end_index: i64,
            /// Citation sources for the attributed segment.
            #[prost(message, repeated, tag = "3")]
            pub sources: ::prost::alloc::vec::Vec<CitationSource>,
        }
        /// Citation source.
        #[derive(Clone, Copy, PartialEq, ::prost::Message)]
        pub struct CitationSource {
            /// Document reference index from SummaryWithMetadata.references.
            /// It is 0-indexed and the value will be zero if the reference_index is
            /// not set explicitly.
            #[prost(int64, tag = "4")]
            pub reference_index: i64,
        }
        /// Document reference.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct Reference {
            /// Title of the document.
            #[prost(string, tag = "1")]
            pub title: ::prost::alloc::string::String,
            /// Required.
            /// [Document.name][google.cloud.discoveryengine.v1alpha.Document.name] of
            /// the document. Full resource name of the referenced document, in the
            /// format
            /// `projects/*/locations/*/collections/*/dataStores/*/branches/*/documents/*`.
            #[prost(string, tag = "2")]
            pub document: ::prost::alloc::string::String,
            /// Cloud Storage or HTTP uri for the document.
            #[prost(string, tag = "3")]
            pub uri: ::prost::alloc::string::String,
            /// List of cited chunk contents derived from document content.
            #[prost(message, repeated, tag = "4")]
            pub chunk_contents: ::prost::alloc::vec::Vec<reference::ChunkContent>,
        }
        /// Nested message and enum types in `Reference`.
        pub mod reference {
            /// Chunk content.
            #[derive(Clone, PartialEq, ::prost::Message)]
            pub struct ChunkContent {
                /// Chunk textual content.
                #[prost(string, tag = "1")]
                pub content: ::prost::alloc::string::String,
                /// Page identifier.
                #[prost(string, tag = "2")]
                pub page_identifier: ::prost::alloc::string::String,
            }
        }
        /// Summary with metadata information.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct SummaryWithMetadata {
            /// Summary text with no citation information.
            #[prost(string, tag = "1")]
            pub summary: ::prost::alloc::string::String,
            /// Citation metadata for given summary.
            #[prost(message, optional, tag = "2")]
            pub citation_metadata: ::core::option::Option<CitationMetadata>,
            /// Document References.
            #[prost(message, repeated, tag = "3")]
            pub references: ::prost::alloc::vec::Vec<Reference>,
        }
        /// An Enum for summary-skipped reasons.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum SummarySkippedReason {
            /// Default value. The summary skipped reason is not specified.
            Unspecified = 0,
            /// The adversarial query ignored case.
            ///
            /// Only used when
            /// [SummarySpec.ignore_adversarial_query][google.cloud.discoveryengine.v1alpha.SearchRequest.ContentSearchSpec.SummarySpec.ignore_adversarial_query]
            /// is set to `true`.
            AdversarialQueryIgnored = 1,
            /// The non-summary seeking query ignored case.
            ///
            /// Only used when
            /// [SummarySpec.ignore_non_summary_seeking_query][google.cloud.discoveryengine.v1alpha.SearchRequest.ContentSearchSpec.SummarySpec.ignore_non_summary_seeking_query]
            /// is set to `true`.
            NonSummarySeekingQueryIgnored = 2,
            /// The out-of-domain query ignored case.
            ///
            /// Google skips the summary if there are no high-relevance search results.
            /// For example, the data store contains facts about company A but the
            /// user query is asking questions about company B.
            OutOfDomainQueryIgnored = 3,
            /// The potential policy violation case.
            ///
            /// Google skips the summary if there is a potential policy violation
            /// detected. This includes content that may be violent or toxic.
            PotentialPolicyViolation = 4,
            /// The LLM addon not enabled case.
            ///
            /// Google skips the summary if the LLM addon is not enabled.
            LlmAddonNotEnabled = 5,
            /// The no relevant content case.
            ///
            /// Google skips the summary if there is no relevant content in the
            /// retrieved search results.
            NoRelevantContent = 6,
            /// The jail-breaking query ignored case.
            ///
            /// For example, "Reply in the tone of a competing company's CEO".
            /// Only used when
            /// \[SearchRequest.ContentSearchSpec.SummarySpec.ignore_jail_breaking_query\]
            /// is set to `true`.
            JailBreakingQueryIgnored = 7,
            /// The customer policy violation case.
            ///
            /// Google skips the summary if there is a customer policy violation
            /// detected. The policy is defined by the customer.
            CustomerPolicyViolation = 8,
            /// The non-answer seeking query ignored case.
            ///
            /// Only used when
            /// \[SearchRequest.ContentSearchSpec.SummarySpec.ignore_non_answer_seeking_query\]
            /// is set to `true`.
            NonSummarySeekingQueryIgnoredV2 = 9,
        }
        impl SummarySkippedReason {
            /// 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 {
                    SummarySkippedReason::Unspecified => {
                        "SUMMARY_SKIPPED_REASON_UNSPECIFIED"
                    }
                    SummarySkippedReason::AdversarialQueryIgnored => {
                        "ADVERSARIAL_QUERY_IGNORED"
                    }
                    SummarySkippedReason::NonSummarySeekingQueryIgnored => {
                        "NON_SUMMARY_SEEKING_QUERY_IGNORED"
                    }
                    SummarySkippedReason::OutOfDomainQueryIgnored => {
                        "OUT_OF_DOMAIN_QUERY_IGNORED"
                    }
                    SummarySkippedReason::PotentialPolicyViolation => {
                        "POTENTIAL_POLICY_VIOLATION"
                    }
                    SummarySkippedReason::LlmAddonNotEnabled => "LLM_ADDON_NOT_ENABLED",
                    SummarySkippedReason::NoRelevantContent => "NO_RELEVANT_CONTENT",
                    SummarySkippedReason::JailBreakingQueryIgnored => {
                        "JAIL_BREAKING_QUERY_IGNORED"
                    }
                    SummarySkippedReason::CustomerPolicyViolation => {
                        "CUSTOMER_POLICY_VIOLATION"
                    }
                    SummarySkippedReason::NonSummarySeekingQueryIgnoredV2 => {
                        "NON_SUMMARY_SEEKING_QUERY_IGNORED_V2"
                    }
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "SUMMARY_SKIPPED_REASON_UNSPECIFIED" => Some(Self::Unspecified),
                    "ADVERSARIAL_QUERY_IGNORED" => Some(Self::AdversarialQueryIgnored),
                    "NON_SUMMARY_SEEKING_QUERY_IGNORED" => {
                        Some(Self::NonSummarySeekingQueryIgnored)
                    }
                    "OUT_OF_DOMAIN_QUERY_IGNORED" => Some(Self::OutOfDomainQueryIgnored),
                    "POTENTIAL_POLICY_VIOLATION" => Some(Self::PotentialPolicyViolation),
                    "LLM_ADDON_NOT_ENABLED" => Some(Self::LlmAddonNotEnabled),
                    "NO_RELEVANT_CONTENT" => Some(Self::NoRelevantContent),
                    "JAIL_BREAKING_QUERY_IGNORED" => Some(Self::JailBreakingQueryIgnored),
                    "CUSTOMER_POLICY_VIOLATION" => Some(Self::CustomerPolicyViolation),
                    "NON_SUMMARY_SEEKING_QUERY_IGNORED_V2" => {
                        Some(Self::NonSummarySeekingQueryIgnoredV2)
                    }
                    _ => None,
                }
            }
        }
    }
    /// Debug information specifically related to forward geocoding issues arising
    /// from Geolocation Search.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct GeoSearchDebugInfo {
        /// The address from which forward geocoding ingestion produced issues.
        #[prost(string, tag = "1")]
        pub original_address_query: ::prost::alloc::string::String,
        /// The error produced.
        #[prost(string, tag = "2")]
        pub error_message: ::prost::alloc::string::String,
    }
    /// Information describing query expansion including whether expansion has
    /// occurred.
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct QueryExpansionInfo {
        /// Bool describing whether query expansion has occurred.
        #[prost(bool, tag = "1")]
        pub expanded_query: bool,
        /// Number of pinned results. This field will only be set when expansion
        /// happens and
        /// [SearchRequest.QueryExpansionSpec.pin_unexpanded_results][google.cloud.discoveryengine.v1alpha.SearchRequest.QueryExpansionSpec.pin_unexpanded_results]
        /// is set to true.
        #[prost(int64, tag = "2")]
        pub pinned_result_count: i64,
    }
    /// Information describing what natural language understanding was
    /// done on the input query.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct NaturalLanguageQueryUnderstandingInfo {
        /// The filters that were extracted from the input query.
        #[prost(string, tag = "1")]
        pub extracted_filters: ::prost::alloc::string::String,
        /// Rewritten input query minus the extracted filters.
        #[prost(string, tag = "2")]
        pub rewritten_query: ::prost::alloc::string::String,
        /// The filters that were extracted from the input query represented in a
        /// structured form.
        #[prost(message, optional, tag = "3")]
        pub structured_extracted_filter: ::core::option::Option<
            natural_language_query_understanding_info::StructuredExtractedFilter,
        >,
    }
    /// Nested message and enum types in `NaturalLanguageQueryUnderstandingInfo`.
    pub mod natural_language_query_understanding_info {
        /// The filters that were extracted from the input query represented in a
        /// structured form.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct StructuredExtractedFilter {
            /// The expression denoting the filter that was extracted from the input
            /// query in a structured form. It can be a simple expression denoting a
            /// single string, numerical or geolocation constraint or a compound
            /// expression which is a combination of multiple expressions connected
            /// using logical (OR and AND) operators.
            #[prost(message, optional, tag = "1")]
            pub expression: ::core::option::Option<
                structured_extracted_filter::Expression,
            >,
        }
        /// Nested message and enum types in `StructuredExtractedFilter`.
        pub mod structured_extracted_filter {
            /// Constraint expression of a string field.
            #[derive(Clone, PartialEq, ::prost::Message)]
            pub struct StringConstraint {
                /// Name of the string field as defined in the schema.
                #[prost(string, tag = "1")]
                pub field_name: ::prost::alloc::string::String,
                /// Values of the string field. The record will only be returned if the
                /// field value matches one of the values specified here.
                #[prost(string, repeated, tag = "2")]
                pub values: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
                /// Identifies the keywords within the search query that match a filter.
                #[prost(string, tag = "3")]
                pub query_segment: ::prost::alloc::string::String,
            }
            /// Constraint expression of a number field. Example: price < 100.
            #[derive(Clone, PartialEq, ::prost::Message)]
            pub struct NumberConstraint {
                /// Name of the numerical field as defined in the schema.
                #[prost(string, tag = "1")]
                pub field_name: ::prost::alloc::string::String,
                /// The comparison operation performed between the field value and the
                /// value specified in the constraint.
                #[prost(enumeration = "number_constraint::Comparison", tag = "2")]
                pub comparison: i32,
                /// The value specified in the numerical constraint.
                #[prost(double, tag = "3")]
                pub value: f64,
                /// Identifies the keywords within the search query that match a filter.
                #[prost(string, tag = "4")]
                pub query_segment: ::prost::alloc::string::String,
            }
            /// Nested message and enum types in `NumberConstraint`.
            pub mod number_constraint {
                /// The comparison operation that was performed.
                #[derive(
                    Clone,
                    Copy,
                    Debug,
                    PartialEq,
                    Eq,
                    Hash,
                    PartialOrd,
                    Ord,
                    ::prost::Enumeration
                )]
                #[repr(i32)]
                pub enum Comparison {
                    /// Undefined comparison operator.
                    Unspecified = 0,
                    /// Denotes equality `=` operator.
                    Equals = 1,
                    /// Denotes less than or equal to `<=` operator.
                    LessThanEquals = 2,
                    /// Denotes less than `<` operator.
                    LessThan = 3,
                    /// Denotes greater than or equal to `>=` operator.
                    GreaterThanEquals = 4,
                    /// Denotes greater than `>` operator.
                    GreaterThan = 5,
                }
                impl Comparison {
                    /// 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 {
                            Comparison::Unspecified => "COMPARISON_UNSPECIFIED",
                            Comparison::Equals => "EQUALS",
                            Comparison::LessThanEquals => "LESS_THAN_EQUALS",
                            Comparison::LessThan => "LESS_THAN",
                            Comparison::GreaterThanEquals => "GREATER_THAN_EQUALS",
                            Comparison::GreaterThan => "GREATER_THAN",
                        }
                    }
                    /// Creates an enum from field names used in the ProtoBuf definition.
                    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                        match value {
                            "COMPARISON_UNSPECIFIED" => Some(Self::Unspecified),
                            "EQUALS" => Some(Self::Equals),
                            "LESS_THAN_EQUALS" => Some(Self::LessThanEquals),
                            "LESS_THAN" => Some(Self::LessThan),
                            "GREATER_THAN_EQUALS" => Some(Self::GreaterThanEquals),
                            "GREATER_THAN" => Some(Self::GreaterThan),
                            _ => None,
                        }
                    }
                }
            }
            /// Constraint of a geolocation field.
            /// Name of the geolocation field as defined in the schema.
            #[derive(Clone, PartialEq, ::prost::Message)]
            pub struct GeolocationConstraint {
                /// The name of the geolocation field as defined in the schema.
                #[prost(string, tag = "1")]
                pub field_name: ::prost::alloc::string::String,
                /// The reference address that was inferred from the input query. The
                /// proximity of the reference address to the geolocation field will be
                /// used to filter the results.
                #[prost(string, tag = "2")]
                pub address: ::prost::alloc::string::String,
                /// The latitude of the geolocation inferred from the input query.
                #[prost(double, tag = "4")]
                pub latitude: f64,
                /// The longitude of the geolocation inferred from the input query.
                #[prost(double, tag = "5")]
                pub longitude: f64,
                /// The radius in meters around the address. The record is returned if
                /// the location of the geolocation field is within the radius.
                #[prost(float, tag = "3")]
                pub radius_in_meters: f32,
            }
            /// Logical `And` operator.
            #[derive(Clone, PartialEq, ::prost::Message)]
            pub struct AndExpression {
                /// The expressions that were ANDed together.
                #[prost(message, repeated, tag = "1")]
                pub expressions: ::prost::alloc::vec::Vec<Expression>,
            }
            /// Logical `Or` operator.
            #[derive(Clone, PartialEq, ::prost::Message)]
            pub struct OrExpression {
                /// The expressions that were ORed together.
                #[prost(message, repeated, tag = "1")]
                pub expressions: ::prost::alloc::vec::Vec<Expression>,
            }
            /// The expression denoting the filter that was extracted from the input
            /// query.
            #[derive(Clone, PartialEq, ::prost::Message)]
            pub struct Expression {
                /// The expression type.
                #[prost(oneof = "expression::Expr", tags = "1, 2, 3, 4, 5")]
                pub expr: ::core::option::Option<expression::Expr>,
            }
            /// Nested message and enum types in `Expression`.
            pub mod expression {
                /// The expression type.
                #[derive(Clone, PartialEq, ::prost::Oneof)]
                pub enum Expr {
                    /// String constraint expression.
                    #[prost(message, tag = "1")]
                    StringConstraint(super::StringConstraint),
                    /// Numerical constraint expression.
                    #[prost(message, tag = "2")]
                    NumberConstraint(super::NumberConstraint),
                    /// Geolocation constraint expression.
                    #[prost(message, tag = "3")]
                    GeolocationConstraint(super::GeolocationConstraint),
                    /// Logical "And" compound operator connecting multiple expressions.
                    #[prost(message, tag = "4")]
                    AndExpr(super::AndExpression),
                    /// Logical "Or" compound operator connecting multiple expressions.
                    #[prost(message, tag = "5")]
                    OrExpr(super::OrExpression),
                }
            }
        }
    }
    /// Information about the session.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct SessionInfo {
        /// Name of the session.
        /// If the auto-session mode is used (when
        /// [SearchRequest.session][google.cloud.discoveryengine.v1alpha.SearchRequest.session]
        /// ends with "-"), this field holds the newly generated session name.
        #[prost(string, tag = "1")]
        pub name: ::prost::alloc::string::String,
        /// Query ID that corresponds to this search API call.
        /// One session can have multiple turns, each with a unique query ID.
        ///
        /// By specifying the session name and this query ID in the Answer API call,
        /// the answer generation happens in the context of the search results from
        /// this search call.
        #[prost(string, tag = "2")]
        pub query_id: ::prost::alloc::string::String,
    }
    /// OneBoxResult is a holder for all results of specific type that we want
    /// to display in UI differently.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct OneBoxResult {
        /// The type of One Box result.
        #[prost(enumeration = "one_box_result::OneBoxType", tag = "1")]
        pub one_box_type: i32,
        /// The search results for this One Box.
        #[prost(message, repeated, tag = "2")]
        pub search_results: ::prost::alloc::vec::Vec<SearchResult>,
    }
    /// Nested message and enum types in `OneBoxResult`.
    pub mod one_box_result {
        /// The type of One Box result.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum OneBoxType {
            /// Default value. Should not be used.
            Unspecified = 0,
            /// One Box result contains people results.
            People = 1,
            /// One Box result contains organization results.
            Organization = 2,
            /// One Box result contains slack results.
            Slack = 3,
        }
        impl OneBoxType {
            /// 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 {
                    OneBoxType::Unspecified => "ONE_BOX_TYPE_UNSPECIFIED",
                    OneBoxType::People => "PEOPLE",
                    OneBoxType::Organization => "ORGANIZATION",
                    OneBoxType::Slack => "SLACK",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "ONE_BOX_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                    "PEOPLE" => Some(Self::People),
                    "ORGANIZATION" => Some(Self::Organization),
                    "SLACK" => Some(Self::Slack),
                    _ => None,
                }
            }
        }
    }
}
/// Generated client implementations.
pub mod search_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for search.
    #[derive(Debug, Clone)]
    pub struct SearchServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl<T> SearchServiceClient<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,
        ) -> SearchServiceClient<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,
        {
            SearchServiceClient::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
        }
        /// Performs a search.
        pub async fn search(
            &mut self,
            request: impl tonic::IntoRequest<super::SearchRequest>,
        ) -> std::result::Result<tonic::Response<super::SearchResponse>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.SearchService/Search",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.SearchService",
                        "Search",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// A SampleQuerySet is the parent resource of SampleQuery, and contains the
/// configurations shared by all SampleQuery under it.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SampleQuerySet {
    /// Identifier. The full resource name of the
    /// [SampleQuerySet][google.cloud.discoveryengine.v1alpha.SampleQuerySet], in
    /// the format of
    /// `projects/{project}/locations/{location}/sampleQuerySets/{sample_query_set}`.
    ///
    /// This field must be a UTF-8 encoded string with a length limit of 1024
    /// characters.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. The sample query set display name.
    ///
    /// This field must be a UTF-8 encoded string with a length limit of 128
    /// characters.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// Output only. Timestamp the
    /// [SampleQuerySet][google.cloud.discoveryengine.v1alpha.SampleQuerySet] was
    /// created at.
    #[prost(message, optional, tag = "3")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// The description of the
    /// [SampleQuerySet][google.cloud.discoveryengine.v1alpha.SampleQuerySet].
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
}
/// Request message for
/// [SampleQuerySetService.GetSampleQuerySet][google.cloud.discoveryengine.v1alpha.SampleQuerySetService.GetSampleQuerySet]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetSampleQuerySetRequest {
    /// Required. Full resource name of
    /// [SampleQuerySet][google.cloud.discoveryengine.v1alpha.SampleQuerySet], such
    /// as
    /// `projects/{project}/locations/{location}/sampleQuerySets/{sample_query_set}`.
    ///
    /// If the caller does not have permission to access the
    /// [SampleQuerySet][google.cloud.discoveryengine.v1alpha.SampleQuerySet],
    /// regardless of whether or not it exists, a PERMISSION_DENIED error is
    /// returned.
    ///
    /// If the requested
    /// [SampleQuerySet][google.cloud.discoveryengine.v1alpha.SampleQuerySet] does
    /// not exist, a NOT_FOUND error is returned.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for
/// [SampleQuerySetService.ListSampleQuerySets][google.cloud.discoveryengine.v1alpha.SampleQuerySetService.ListSampleQuerySets]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListSampleQuerySetsRequest {
    /// Required. The parent location resource name, such as
    /// `projects/{project}/locations/{location}`.
    ///
    /// If the caller does not have permission to list
    /// [SampleQuerySet][google.cloud.discoveryengine.v1alpha.SampleQuerySet]s
    /// under this location, regardless of whether or not this location exists, a
    /// `PERMISSION_DENIED` error is returned.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Maximum number of
    /// [SampleQuerySet][google.cloud.discoveryengine.v1alpha.SampleQuerySet]s to
    /// return. If unspecified, defaults to 100. The maximum allowed value is 1000.
    /// Values above 1000 will be coerced to 1000.
    ///
    /// If this field is negative, an `INVALID_ARGUMENT` error is returned.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// A page token
    /// [ListSampleQuerySetsResponse.next_page_token][google.cloud.discoveryengine.v1alpha.ListSampleQuerySetsResponse.next_page_token],
    /// received from a previous
    /// [SampleQuerySetService.ListSampleQuerySets][google.cloud.discoveryengine.v1alpha.SampleQuerySetService.ListSampleQuerySets]
    /// call. Provide this to retrieve the subsequent page.
    ///
    /// When paginating, all other parameters provided to
    /// [SampleQuerySetService.ListSampleQuerySets][google.cloud.discoveryengine.v1alpha.SampleQuerySetService.ListSampleQuerySets]
    /// must match the call that provided the page token. Otherwise, an
    /// `INVALID_ARGUMENT` error is returned.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// Response message for
/// [SampleQuerySetService.ListSampleQuerySets][google.cloud.discoveryengine.v1alpha.SampleQuerySetService.ListSampleQuerySets]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListSampleQuerySetsResponse {
    /// The [SampleQuerySet][google.cloud.discoveryengine.v1alpha.SampleQuerySet]s.
    #[prost(message, repeated, tag = "1")]
    pub sample_query_sets: ::prost::alloc::vec::Vec<SampleQuerySet>,
    /// A token that can be sent as
    /// [ListSampleQuerySetsRequest.page_token][google.cloud.discoveryengine.v1alpha.ListSampleQuerySetsRequest.page_token]
    /// to retrieve the next page. If this field is omitted, there are no
    /// subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for
/// [SampleQuerySetService.CreateSampleQuerySet][google.cloud.discoveryengine.v1alpha.SampleQuerySetService.CreateSampleQuerySet]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateSampleQuerySetRequest {
    /// Required. The parent resource name, such as
    /// `projects/{project}/locations/{location}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The
    /// [SampleQuerySet][google.cloud.discoveryengine.v1alpha.SampleQuerySet] to
    /// create.
    #[prost(message, optional, tag = "2")]
    pub sample_query_set: ::core::option::Option<SampleQuerySet>,
    /// Required. The ID to use for the
    /// [SampleQuerySet][google.cloud.discoveryengine.v1alpha.SampleQuerySet],
    /// which will become the final component of the
    /// [SampleQuerySet.name][google.cloud.discoveryengine.v1alpha.SampleQuerySet.name].
    ///
    /// If the caller does not have permission to create the
    /// [SampleQuerySet][google.cloud.discoveryengine.v1alpha.SampleQuerySet],
    /// regardless of whether or not it exists, a `PERMISSION_DENIED` error is
    /// returned.
    ///
    /// This field must be unique among all
    /// [SampleQuerySet][google.cloud.discoveryengine.v1alpha.SampleQuerySet]s with
    /// the same
    /// [parent][google.cloud.discoveryengine.v1alpha.CreateSampleQuerySetRequest.parent].
    /// Otherwise, an `ALREADY_EXISTS` error is returned.
    ///
    /// This field must conform to [RFC-1034](<https://tools.ietf.org/html/rfc1034>)
    /// standard with a length limit of 63 characters. Otherwise, an
    /// `INVALID_ARGUMENT` error is returned.
    #[prost(string, tag = "3")]
    pub sample_query_set_id: ::prost::alloc::string::String,
}
/// Request message for
/// [SampleQuerySetService.UpdateSampleQuerySet][google.cloud.discoveryengine.v1alpha.SampleQuerySetService.UpdateSampleQuerySet]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateSampleQuerySetRequest {
    /// Required. The sample query set to update.
    ///
    /// If the caller does not have permission to update the
    /// [SampleQuerySet][google.cloud.discoveryengine.v1alpha.SampleQuerySet],
    /// regardless of whether or not it exists, a `PERMISSION_DENIED` error is
    /// returned.
    ///
    /// If the
    /// [SampleQuerySet][google.cloud.discoveryengine.v1alpha.SampleQuerySet] to
    /// update does not exist a `NOT_FOUND` error is returned.
    #[prost(message, optional, tag = "1")]
    pub sample_query_set: ::core::option::Option<SampleQuerySet>,
    /// Indicates which fields in the provided imported 'sample query set' to
    /// update. If not set, will by default update all fields.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request message for
/// [SampleQuerySetService.DeleteSampleQuerySet][google.cloud.discoveryengine.v1alpha.SampleQuerySetService.DeleteSampleQuerySet]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteSampleQuerySetRequest {
    /// Required. Full resource name of
    /// [SampleQuerySet][google.cloud.discoveryengine.v1alpha.SampleQuerySet], such
    /// as
    /// `projects/{project}/locations/{location}/sampleQuerySets/{sample_query_set}`.
    ///
    /// If the caller does not have permission to delete the
    /// [SampleQuerySet][google.cloud.discoveryengine.v1alpha.SampleQuerySet],
    /// regardless of whether or not it exists, a `PERMISSION_DENIED` error is
    /// returned.
    ///
    /// If the
    /// [SampleQuerySet][google.cloud.discoveryengine.v1alpha.SampleQuerySet] to
    /// delete does not exist, a `NOT_FOUND` error is returned.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod sample_query_set_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for managing
    /// [SampleQuerySet][google.cloud.discoveryengine.v1alpha.SampleQuerySet]s,
    #[derive(Debug, Clone)]
    pub struct SampleQuerySetServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl<T> SampleQuerySetServiceClient<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,
        ) -> SampleQuerySetServiceClient<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,
        {
            SampleQuerySetServiceClient::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
        }
        /// Gets a
        /// [SampleQuerySet][google.cloud.discoveryengine.v1alpha.SampleQuerySet].
        pub async fn get_sample_query_set(
            &mut self,
            request: impl tonic::IntoRequest<super::GetSampleQuerySetRequest>,
        ) -> std::result::Result<tonic::Response<super::SampleQuerySet>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.SampleQuerySetService/GetSampleQuerySet",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.SampleQuerySetService",
                        "GetSampleQuerySet",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets a list of
        /// [SampleQuerySet][google.cloud.discoveryengine.v1alpha.SampleQuerySet]s.
        pub async fn list_sample_query_sets(
            &mut self,
            request: impl tonic::IntoRequest<super::ListSampleQuerySetsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListSampleQuerySetsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.SampleQuerySetService/ListSampleQuerySets",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.SampleQuerySetService",
                        "ListSampleQuerySets",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a
        /// [SampleQuerySet][google.cloud.discoveryengine.v1alpha.SampleQuerySet]
        pub async fn create_sample_query_set(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateSampleQuerySetRequest>,
        ) -> std::result::Result<tonic::Response<super::SampleQuerySet>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.SampleQuerySetService/CreateSampleQuerySet",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.SampleQuerySetService",
                        "CreateSampleQuerySet",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates a
        /// [SampleQuerySet][google.cloud.discoveryengine.v1alpha.SampleQuerySet].
        pub async fn update_sample_query_set(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateSampleQuerySetRequest>,
        ) -> std::result::Result<tonic::Response<super::SampleQuerySet>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.SampleQuerySetService/UpdateSampleQuerySet",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.SampleQuerySetService",
                        "UpdateSampleQuerySet",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes a
        /// [SampleQuerySet][google.cloud.discoveryengine.v1alpha.SampleQuerySet].
        pub async fn delete_sample_query_set(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteSampleQuerySetRequest>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.SampleQuerySetService/DeleteSampleQuerySet",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.SampleQuerySetService",
                        "DeleteSampleQuerySet",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Access Control Configuration.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AclConfig {
    /// Immutable. The full resource name of the acl configuration.
    /// Format:
    /// `projects/{project}/locations/{location}/aclConfig`.
    ///
    /// This field must be a UTF-8 encoded string with a length limit of 1024
    /// characters.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Identity provider config.
    #[prost(message, optional, tag = "2")]
    pub idp_config: ::core::option::Option<IdpConfig>,
}
/// Suggestion deny list entry identifying the phrase to block from suggestions
/// and the applied operation for the phrase.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SuggestionDenyListEntry {
    /// Required. Phrase to block from suggestions served. Can be maximum 125
    /// characters.
    #[prost(string, tag = "1")]
    pub block_phrase: ::prost::alloc::string::String,
    /// Required. The match operator to apply for this phrase. Whether to block the
    /// exact phrase, or block any suggestions containing this phrase.
    #[prost(enumeration = "suggestion_deny_list_entry::MatchOperator", tag = "2")]
    pub match_operator: i32,
}
/// Nested message and enum types in `SuggestionDenyListEntry`.
pub mod suggestion_deny_list_entry {
    /// Operator for matching with the generated suggestions.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum MatchOperator {
        /// Default value. Should not be used
        Unspecified = 0,
        /// If the suggestion is an exact match to the block_phrase, then block it.
        ExactMatch = 1,
        /// If the suggestion contains the block_phrase, then block it.
        Contains = 2,
    }
    impl MatchOperator {
        /// 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 {
                MatchOperator::Unspecified => "MATCH_OPERATOR_UNSPECIFIED",
                MatchOperator::ExactMatch => "EXACT_MATCH",
                MatchOperator::Contains => "CONTAINS",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "MATCH_OPERATOR_UNSPECIFIED" => Some(Self::Unspecified),
                "EXACT_MATCH" => Some(Self::ExactMatch),
                "CONTAINS" => Some(Self::Contains),
                _ => None,
            }
        }
    }
}
/// Autocomplete suggestions that are imported from Customer.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CompletionSuggestion {
    /// Required. The suggestion text.
    #[prost(string, tag = "1")]
    pub suggestion: ::prost::alloc::string::String,
    /// BCP-47 language code of this suggestion.
    #[prost(string, tag = "4")]
    pub language_code: ::prost::alloc::string::String,
    /// If two suggestions have the same groupId, they will not be
    /// returned together. Instead the one ranked higher will be returned. This can
    /// be used to deduplicate semantically identical suggestions.
    #[prost(string, tag = "5")]
    pub group_id: ::prost::alloc::string::String,
    /// The score of this suggestion within its group.
    #[prost(double, tag = "6")]
    pub group_score: f64,
    /// Alternative matching phrases for this suggestion.
    #[prost(string, repeated, tag = "7")]
    pub alternative_phrases: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Ranking metrics of this suggestion.
    #[prost(oneof = "completion_suggestion::RankingInfo", tags = "2, 3")]
    pub ranking_info: ::core::option::Option<completion_suggestion::RankingInfo>,
}
/// Nested message and enum types in `CompletionSuggestion`.
pub mod completion_suggestion {
    /// Ranking metrics of this suggestion.
    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
    pub enum RankingInfo {
        /// Global score of this suggestion. Control how this suggestion would be
        /// scored / ranked.
        #[prost(double, tag = "2")]
        GlobalScore(f64),
        /// Frequency of this suggestion. Will be used to rank suggestions when score
        /// is not available.
        #[prost(int64, tag = "3")]
        Frequency(i64),
    }
}
/// Sample Query captures metadata to be used for evaluation.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SampleQuery {
    /// Identifier. The full resource name of the sample query, in the format of
    /// `projects/{project}/locations/{location}/sampleQuerySets/{sample_query_set}/sampleQueries/{sample_query}`.
    ///
    /// This field must be a UTF-8 encoded string with a length limit of 1024
    /// characters.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. Timestamp the
    /// [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery] was created
    /// at.
    #[prost(message, optional, tag = "3")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// The content of the sample query.
    #[prost(oneof = "sample_query::Content", tags = "2")]
    pub content: ::core::option::Option<sample_query::Content>,
}
/// Nested message and enum types in `SampleQuery`.
pub mod sample_query {
    /// Query Entry captures metadata to be used for search evaluation.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct QueryEntry {
        /// Required. The query.
        #[prost(string, tag = "1")]
        pub query: ::prost::alloc::string::String,
        /// List of targets for the query.
        #[prost(message, repeated, tag = "3")]
        pub targets: ::prost::alloc::vec::Vec<query_entry::Target>,
    }
    /// Nested message and enum types in `QueryEntry`.
    pub mod query_entry {
        /// Defines the parameters of the query's expected outcome.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct Target {
            /// Expected uri of the target.
            ///
            /// This field must be a UTF-8 encoded string with a length limit of 2048
            /// characters.
            ///
            /// Example of valid uris: `<https://example.com/abc`,>
            /// `gcs://example/example.pdf`.
            #[prost(string, tag = "1")]
            pub uri: ::prost::alloc::string::String,
            /// Expected page numbers of the target.
            ///
            /// Each page number must be non negative.
            #[prost(int32, repeated, tag = "2")]
            pub page_numbers: ::prost::alloc::vec::Vec<i32>,
            /// Relevance score of the target.
            #[prost(double, optional, tag = "3")]
            pub score: ::core::option::Option<f64>,
        }
    }
    /// The content of the sample query.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Content {
        /// The query entry.
        #[prost(message, tag = "2")]
        QueryEntry(QueryEntry),
    }
}
/// UserEvent captures all metadata information Discovery Engine API needs to
/// know about how end users interact with your website.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UserEvent {
    /// Required. User event type. Allowed values are:
    ///
    /// Generic values:
    ///
    /// * `search`: Search for Documents.
    /// * `view-item`: Detailed page view of a Document.
    /// * `view-item-list`: View of a panel or ordered list of Documents.
    /// * `view-home-page`: View of the home page.
    /// * `view-category-page`: View of a category page, e.g. Home > Men > Jeans
    ///
    /// Retail-related values:
    ///
    /// * `add-to-cart`: Add an item(s) to cart, e.g. in Retail online shopping
    /// * `purchase`: Purchase an item(s)
    ///
    /// Media-related values:
    ///
    /// * `media-play`: Start/resume watching a video, playing a song, etc.
    /// * `media-complete`: Finished or stopped midway through a video, song, etc.
    #[prost(string, tag = "1")]
    pub event_type: ::prost::alloc::string::String,
    /// Required. A unique identifier for tracking visitors.
    ///
    /// For example, this could be implemented with an HTTP cookie, which should be
    /// able to uniquely identify a visitor on a single device. This unique
    /// identifier should not change if the visitor log in/out of the website.
    ///
    /// Do not set the field to the same fixed ID for different users. This mixes
    /// the event history of those users together, which results in degraded model
    /// quality.
    ///
    /// The field must be a UTF-8 encoded string with a length limit of 128
    /// characters. Otherwise, an `INVALID_ARGUMENT` error is returned.
    ///
    /// The field should not contain PII or user-data. We recommend to use Google
    /// Analytics [Client
    /// ID](<https://developers.google.com/analytics/devguides/collection/analyticsjs/field-reference#clientId>)
    /// for this field.
    #[prost(string, tag = "2")]
    pub user_pseudo_id: ::prost::alloc::string::String,
    /// The [Engine][google.cloud.discoveryengine.v1alpha.Engine] resource name, in
    /// the form of
    /// `projects/{project}/locations/{location}/collections/{collection_id}/engines/{engine_id}`.
    ///
    /// Optional. Only required for
    /// [Engine][google.cloud.discoveryengine.v1alpha.Engine] produced user events.
    /// For example, user events from blended search.
    #[prost(string, tag = "19")]
    pub engine: ::prost::alloc::string::String,
    /// The [DataStore][google.cloud.discoveryengine.v1alpha.DataStore] resource
    /// full name, of the form
    /// `projects/{project}/locations/{location}/collections/{collection_id}/dataStores/{data_store_id}`.
    ///
    /// Optional. Only required for user events whose data store can't by
    /// determined by
    /// [UserEvent.engine][google.cloud.discoveryengine.v1alpha.UserEvent.engine]
    /// or
    /// [UserEvent.documents][google.cloud.discoveryengine.v1alpha.UserEvent.documents].
    /// If data store is set in the parent of write/import/collect user event
    /// requests, this field can be omitted.
    #[prost(string, tag = "20")]
    pub data_store: ::prost::alloc::string::String,
    /// Only required for
    /// [UserEventService.ImportUserEvents][google.cloud.discoveryengine.v1alpha.UserEventService.ImportUserEvents]
    /// method. Timestamp of when the user event happened.
    #[prost(message, optional, tag = "3")]
    pub event_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Information about the end user.
    #[prost(message, optional, tag = "4")]
    pub user_info: ::core::option::Option<UserInfo>,
    /// Should set to true if the request is made directly from the end user, in
    /// which case the
    /// [UserEvent.user_info.user_agent][google.cloud.discoveryengine.v1alpha.UserInfo.user_agent]
    /// can be populated from the HTTP request.
    ///
    /// This flag should be set only if the API request is made directly from the
    /// end user such as a mobile app (and not if a gateway or a server is
    /// processing and pushing the user events).
    ///
    /// This should not be set when using the JavaScript tag in
    /// [UserEventService.CollectUserEvent][google.cloud.discoveryengine.v1alpha.UserEventService.CollectUserEvent].
    #[prost(bool, tag = "5")]
    pub direct_user_request: bool,
    /// A unique identifier for tracking a visitor session with a length limit of
    /// 128 bytes. A session is an aggregation of an end user behavior in a time
    /// span.
    ///
    /// A general guideline to populate the session_id:
    ///
    /// 1. If user has no activity for 30 min, a new session_id should be assigned.
    /// 2. The session_id should be unique across users, suggest use uuid or add
    /// [UserEvent.user_pseudo_id][google.cloud.discoveryengine.v1alpha.UserEvent.user_pseudo_id]
    /// as prefix.
    #[prost(string, tag = "6")]
    pub session_id: ::prost::alloc::string::String,
    /// Page metadata such as categories and other critical information for certain
    /// event types such as `view-category-page`.
    #[prost(message, optional, tag = "7")]
    pub page_info: ::core::option::Option<PageInfo>,
    /// Token to attribute an API response to user action(s) to trigger the event.
    ///
    /// Highly recommended for user events that are the result of
    /// [RecommendationService.Recommend][google.cloud.discoveryengine.v1alpha.RecommendationService.Recommend].
    /// This field enables accurate attribution of recommendation model
    /// performance.
    ///
    /// The value must be one of:
    ///
    /// * [RecommendResponse.attribution_token][google.cloud.discoveryengine.v1alpha.RecommendResponse.attribution_token] for events that are the result of
    /// [RecommendationService.Recommend][google.cloud.discoveryengine.v1alpha.RecommendationService.Recommend].
    /// * [SearchResponse.attribution_token][google.cloud.discoveryengine.v1alpha.SearchResponse.attribution_token] for events that are the result of
    /// [SearchService.Search][google.cloud.discoveryengine.v1alpha.SearchService.Search].
    ///
    /// This token enables us to accurately attribute page view or conversion
    /// completion back to the event and the particular predict response containing
    /// this clicked/purchased product. If user clicks on product K in the
    /// recommendation results, pass
    /// [RecommendResponse.attribution_token][google.cloud.discoveryengine.v1alpha.RecommendResponse.attribution_token]
    /// as a URL parameter to product K's page. When recording events on product
    /// K's page, log the
    /// [RecommendResponse.attribution_token][google.cloud.discoveryengine.v1alpha.RecommendResponse.attribution_token]
    /// to this field.
    #[prost(string, tag = "8")]
    pub attribution_token: ::prost::alloc::string::String,
    /// The filter syntax consists of an expression language for constructing a
    /// predicate from one or more fields of the documents being filtered.
    ///
    /// One example is for `search` events, the associated
    /// [SearchRequest][google.cloud.discoveryengine.v1alpha.SearchRequest] may
    /// contain a filter expression in
    /// [SearchRequest.filter][google.cloud.discoveryengine.v1alpha.SearchRequest.filter]
    /// conforming to <https://google.aip.dev/160#filtering.>
    ///
    /// Similarly, for `view-item-list` events that are generated from a
    /// [RecommendRequest][google.cloud.discoveryengine.v1alpha.RecommendRequest],
    /// this field may be populated directly from
    /// [RecommendRequest.filter][google.cloud.discoveryengine.v1alpha.RecommendRequest.filter]
    /// conforming to <https://google.aip.dev/160#filtering.>
    ///
    /// The value must be a UTF-8 encoded string with a length limit of 1,000
    /// characters. Otherwise, an `INVALID_ARGUMENT` error is returned.
    #[prost(string, tag = "9")]
    pub filter: ::prost::alloc::string::String,
    /// List of [Document][google.cloud.discoveryengine.v1alpha.Document]s
    /// associated with this user event.
    ///
    /// This field is optional except for the following event types:
    ///
    /// * `view-item`
    /// * `add-to-cart`
    /// * `purchase`
    /// * `media-play`
    /// * `media-complete`
    ///
    /// In a `search` event, this field represents the documents returned to the
    /// end user on the current page (the end user may have not finished browsing
    /// the whole page yet). When a new page is returned to the end user, after
    /// pagination/filtering/ordering even for the same query, a new `search` event
    /// with different
    /// [UserEvent.documents][google.cloud.discoveryengine.v1alpha.UserEvent.documents]
    /// is desired.
    #[prost(message, repeated, tag = "10")]
    pub documents: ::prost::alloc::vec::Vec<DocumentInfo>,
    /// Panel metadata associated with this user event.
    #[prost(message, optional, tag = "11")]
    pub panel: ::core::option::Option<PanelInfo>,
    /// [SearchService.Search][google.cloud.discoveryengine.v1alpha.SearchService.Search]
    /// details related to the event.
    ///
    /// This field should be set for `search` event.
    #[prost(message, optional, tag = "12")]
    pub search_info: ::core::option::Option<SearchInfo>,
    /// [CompletionService.CompleteQuery][google.cloud.discoveryengine.v1alpha.CompletionService.CompleteQuery]
    /// details related to the event.
    ///
    /// This field should be set for `search` event when autocomplete function is
    /// enabled and the user clicks a suggestion for search.
    #[prost(message, optional, tag = "13")]
    pub completion_info: ::core::option::Option<CompletionInfo>,
    /// The transaction metadata (if any) associated with this user event.
    #[prost(message, optional, tag = "14")]
    pub transaction_info: ::core::option::Option<TransactionInfo>,
    /// A list of identifiers for the independent experiment groups this user event
    /// belongs to. This is used to distinguish between user events associated with
    /// different experiment setups.
    #[prost(string, repeated, tag = "15")]
    pub tag_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// The promotion IDs if this is an event associated with promotions.
    /// Currently, this field is restricted to at most one ID.
    #[prost(string, repeated, tag = "16")]
    pub promotion_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Extra user event features to include in the recommendation model.
    /// These attributes must NOT contain data that needs to be parsed or processed
    /// further, e.g. JSON or other encodings.
    ///
    /// If you provide custom attributes for ingested user events, also include
    /// them in the user events that you associate with prediction requests. Custom
    /// attribute formatting must be consistent between imported events and events
    /// provided with prediction requests. This lets the Discovery Engine API use
    /// those custom attributes when training models and serving predictions, which
    /// helps improve recommendation quality.
    ///
    /// This field needs to pass all below criteria, otherwise an
    /// `INVALID_ARGUMENT` error is returned:
    ///
    /// * The key must be a UTF-8 encoded string with a length limit of 5,000
    ///    characters.
    /// * For text attributes, at most 400 values are allowed. Empty values are not
    ///    allowed. Each value must be a UTF-8 encoded string with a length limit of
    ///    256 characters.
    /// * For number attributes, at most 400 values are allowed.
    ///
    /// For product recommendations, an example of extra user information is
    /// `traffic_channel`, which is how a user arrives at the site. Users can
    /// arrive
    /// at the site by coming to the site directly, coming through Google
    /// search, or in other ways.
    #[prost(btree_map = "string, message", tag = "17")]
    pub attributes: ::prost::alloc::collections::BTreeMap<
        ::prost::alloc::string::String,
        CustomAttribute,
    >,
    /// Media-specific info.
    #[prost(message, optional, tag = "18")]
    pub media_info: ::core::option::Option<MediaInfo>,
}
/// Detailed page information.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PageInfo {
    /// A unique ID of a web page view.
    ///
    /// This should be kept the same for all user events triggered from the same
    /// pageview. For example, an item detail page view could trigger multiple
    /// events as the user is browsing the page. The `pageview_id` property should
    /// be kept the same for all these events so that they can be grouped together
    /// properly.
    ///
    /// When using the client side event reporting with JavaScript pixel and Google
    /// Tag Manager, this value is filled in automatically.
    #[prost(string, tag = "1")]
    pub pageview_id: ::prost::alloc::string::String,
    /// The most specific category associated with a category page.
    ///
    /// To represent full path of category, use '>' sign to separate different
    /// hierarchies. If '>' is part of the category name, replace it with
    /// other character(s).
    ///
    /// Category pages include special pages such as sales or promotions. For
    /// instance, a special sale page may have the category hierarchy:
    /// `"pageCategory" : "Sales > 2017 Black Friday Deals"`.
    ///
    /// Required for `view-category-page` events. Other event types should not set
    /// this field. Otherwise, an `INVALID_ARGUMENT` error is returned.
    #[prost(string, tag = "2")]
    pub page_category: ::prost::alloc::string::String,
    /// Complete URL (window.location.href) of the user's current page.
    ///
    /// When using the client side event reporting with JavaScript pixel and Google
    /// Tag Manager, this value is filled in automatically. Maximum length 5,000
    /// characters.
    #[prost(string, tag = "3")]
    pub uri: ::prost::alloc::string::String,
    /// The referrer URL of the current page.
    ///
    /// When using the client side event reporting with JavaScript pixel and Google
    /// Tag Manager, this value is filled in automatically. However, some browser
    /// privacy restrictions may cause this field to be empty.
    #[prost(string, tag = "4")]
    pub referrer_uri: ::prost::alloc::string::String,
}
/// Detailed search information.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SearchInfo {
    /// The user's search query.
    ///
    /// See
    /// [SearchRequest.query][google.cloud.discoveryengine.v1alpha.SearchRequest.query]
    /// for definition.
    ///
    /// The value must be a UTF-8 encoded string with a length limit of 5,000
    /// characters. Otherwise, an `INVALID_ARGUMENT` error is returned.
    ///
    /// At least one of
    /// [search_query][google.cloud.discoveryengine.v1alpha.SearchInfo.search_query]
    /// or
    /// [PageInfo.page_category][google.cloud.discoveryengine.v1alpha.PageInfo.page_category]
    /// is required for `search` events. Other event types should not set this
    /// field. Otherwise, an `INVALID_ARGUMENT` error is returned.
    #[prost(string, tag = "1")]
    pub search_query: ::prost::alloc::string::String,
    /// The order in which products are returned, if applicable.
    ///
    /// See
    /// [SearchRequest.order_by][google.cloud.discoveryengine.v1alpha.SearchRequest.order_by]
    /// for definition and syntax.
    ///
    /// The value must be a UTF-8 encoded string with a length limit of 1,000
    /// characters. Otherwise, an `INVALID_ARGUMENT` error is returned.
    ///
    /// This can only be set for `search` events. Other event types should not set
    /// this field. Otherwise, an `INVALID_ARGUMENT` error is returned.
    #[prost(string, tag = "2")]
    pub order_by: ::prost::alloc::string::String,
    /// An integer that specifies the current offset for pagination (the 0-indexed
    /// starting location, amongst the products deemed by the API as relevant).
    ///
    /// See
    /// [SearchRequest.offset][google.cloud.discoveryengine.v1alpha.SearchRequest.offset]
    /// for definition.
    ///
    /// If this field is negative, an `INVALID_ARGUMENT` is returned.
    ///
    /// This can only be set for `search` events. Other event types should not set
    /// this field. Otherwise, an `INVALID_ARGUMENT` error is returned.
    #[prost(int32, optional, tag = "3")]
    pub offset: ::core::option::Option<i32>,
}
/// Detailed completion information including completion attribution token and
/// clicked completion info.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CompletionInfo {
    /// End user selected
    /// [CompleteQueryResponse.QuerySuggestion.suggestion][google.cloud.discoveryengine.v1alpha.CompleteQueryResponse.QuerySuggestion.suggestion].
    #[prost(string, tag = "1")]
    pub selected_suggestion: ::prost::alloc::string::String,
    /// End user selected
    /// [CompleteQueryResponse.QuerySuggestion.suggestion][google.cloud.discoveryengine.v1alpha.CompleteQueryResponse.QuerySuggestion.suggestion]
    /// position, starting from 0.
    #[prost(int32, tag = "2")]
    pub selected_position: i32,
}
/// A transaction represents the entire purchase transaction.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TransactionInfo {
    /// Required. Total non-zero value associated with the transaction. This value
    /// may include shipping, tax, or other adjustments to the total value that you
    /// want to include.
    #[prost(float, optional, tag = "1")]
    pub value: ::core::option::Option<f32>,
    /// Required. Currency code. Use three-character ISO-4217 code.
    #[prost(string, tag = "2")]
    pub currency: ::prost::alloc::string::String,
    /// The transaction ID with a length limit of 128 characters.
    #[prost(string, tag = "3")]
    pub transaction_id: ::prost::alloc::string::String,
    /// All the taxes associated with the transaction.
    #[prost(float, optional, tag = "4")]
    pub tax: ::core::option::Option<f32>,
    /// All the costs associated with the products. These can be manufacturing
    /// costs, shipping expenses not borne by the end user, or any other costs,
    /// such that:
    ///
    /// * Profit =
    /// [value][google.cloud.discoveryengine.v1alpha.TransactionInfo.value] -
    /// [tax][google.cloud.discoveryengine.v1alpha.TransactionInfo.tax] -
    /// [cost][google.cloud.discoveryengine.v1alpha.TransactionInfo.cost]
    #[prost(float, optional, tag = "5")]
    pub cost: ::core::option::Option<f32>,
    /// The total discount(s) value applied to this transaction.
    /// This figure should be excluded from
    /// [TransactionInfo.value][google.cloud.discoveryengine.v1alpha.TransactionInfo.value]
    ///
    /// For example, if a user paid
    /// [TransactionInfo.value][google.cloud.discoveryengine.v1alpha.TransactionInfo.value]
    /// amount, then nominal (pre-discount) value of the transaction is the sum of
    /// [TransactionInfo.value][google.cloud.discoveryengine.v1alpha.TransactionInfo.value]
    /// and
    /// [TransactionInfo.discount_value][google.cloud.discoveryengine.v1alpha.TransactionInfo.discount_value]
    ///
    /// This means that profit is calculated the same way, regardless of the
    /// discount value, and that
    /// [TransactionInfo.discount_value][google.cloud.discoveryengine.v1alpha.TransactionInfo.discount_value]
    /// can be larger than
    /// [TransactionInfo.value][google.cloud.discoveryengine.v1alpha.TransactionInfo.value]:
    ///
    /// * Profit =
    /// [value][google.cloud.discoveryengine.v1alpha.TransactionInfo.value] -
    /// [tax][google.cloud.discoveryengine.v1alpha.TransactionInfo.tax] -
    /// [cost][google.cloud.discoveryengine.v1alpha.TransactionInfo.cost]
    #[prost(float, optional, tag = "6")]
    pub discount_value: ::core::option::Option<f32>,
}
/// Detailed document information associated with a user event.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DocumentInfo {
    /// Quantity of the Document associated with the user event. Defaults to 1.
    ///
    /// For example, this field is 2 if two quantities of the same Document
    /// are involved in a `add-to-cart` event.
    ///
    /// Required for events of the following event types:
    ///
    /// * `add-to-cart`
    /// * `purchase`
    #[prost(int32, optional, tag = "3")]
    pub quantity: ::core::option::Option<i32>,
    /// The promotion IDs associated with this Document.
    /// Currently, this field is restricted to at most one ID.
    #[prost(string, repeated, tag = "4")]
    pub promotion_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Output only. Whether the referenced Document can be found in the data
    /// store.
    #[prost(bool, tag = "5")]
    pub joined: bool,
    /// A required descriptor of the associated
    /// [Document][google.cloud.discoveryengine.v1alpha.Document].
    ///
    /// * If [id][google.cloud.discoveryengine.v1alpha.DocumentInfo.id] is
    /// specified, then the default values for
    /// `{location}`, `{collection_id}`, `{data_store_id}`, and `{branch_id}` are
    /// used when annotating with the stored Document.
    ///
    /// * If [name][google.cloud.discoveryengine.v1alpha.DocumentInfo.name] is
    /// specified, then the provided values (default values allowed) for
    /// `{location}`, `{collection_id}`, `{data_store_id}`, and
    /// `{branch_id}` are used when annotating with the stored Document.
    #[prost(oneof = "document_info::DocumentDescriptor", tags = "1, 2, 6")]
    pub document_descriptor: ::core::option::Option<document_info::DocumentDescriptor>,
}
/// Nested message and enum types in `DocumentInfo`.
pub mod document_info {
    /// A required descriptor of the associated
    /// [Document][google.cloud.discoveryengine.v1alpha.Document].
    ///
    /// * If [id][google.cloud.discoveryengine.v1alpha.DocumentInfo.id] is
    /// specified, then the default values for
    /// `{location}`, `{collection_id}`, `{data_store_id}`, and `{branch_id}` are
    /// used when annotating with the stored Document.
    ///
    /// * If [name][google.cloud.discoveryengine.v1alpha.DocumentInfo.name] is
    /// specified, then the provided values (default values allowed) for
    /// `{location}`, `{collection_id}`, `{data_store_id}`, and
    /// `{branch_id}` are used when annotating with the stored Document.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum DocumentDescriptor {
        /// The [Document][google.cloud.discoveryengine.v1alpha.Document] resource
        /// ID.
        #[prost(string, tag = "1")]
        Id(::prost::alloc::string::String),
        /// The [Document][google.cloud.discoveryengine.v1alpha.Document] resource
        /// full name, of the form:
        /// `projects/{project_id}/locations/{location}/collections/{collection_id}/dataStores/{data_store_id}/branches/{branch_id}/documents/{document_id}`
        #[prost(string, tag = "2")]
        Name(::prost::alloc::string::String),
        /// The [Document][google.cloud.discoveryengine.v1alpha.Document] URI - only
        /// allowed for website data stores.
        #[prost(string, tag = "6")]
        Uri(::prost::alloc::string::String),
    }
}
/// Detailed panel information associated with a user event.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PanelInfo {
    /// Required. The panel ID.
    #[prost(string, tag = "2")]
    pub panel_id: ::prost::alloc::string::String,
    /// The display name of the panel.
    #[prost(string, tag = "3")]
    pub display_name: ::prost::alloc::string::String,
    /// The ordered position of the panel, if shown to the user with other panels.
    /// If set, then
    /// [total_panels][google.cloud.discoveryengine.v1alpha.PanelInfo.total_panels]
    /// must also be set.
    #[prost(int32, optional, tag = "4")]
    pub panel_position: ::core::option::Option<i32>,
    /// The total number of panels, including this one, shown to the user.
    /// Must be set if
    /// [panel_position][google.cloud.discoveryengine.v1alpha.PanelInfo.panel_position]
    /// is set.
    #[prost(int32, optional, tag = "5")]
    pub total_panels: ::core::option::Option<i32>,
}
/// Media-specific user event information.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct MediaInfo {
    /// The media progress time in seconds, if applicable.
    /// For example, if the end user has finished 90 seconds of a playback video,
    /// then
    /// [MediaInfo.media_progress_duration.seconds][google.protobuf.Duration.seconds]
    /// should be set to 90.
    #[prost(message, optional, tag = "1")]
    pub media_progress_duration: ::core::option::Option<::prost_types::Duration>,
    /// Media progress should be computed using only the
    /// [media_progress_duration][google.cloud.discoveryengine.v1alpha.MediaInfo.media_progress_duration]
    /// relative to the media total length.
    ///
    /// This value must be between `\[0, 1.0\]` inclusive.
    ///
    /// If this is not a playback or the progress cannot be computed (e.g. ongoing
    /// livestream), this field should be unset.
    #[prost(float, optional, tag = "2")]
    pub media_progress_percentage: ::core::option::Option<f32>,
}
/// Cloud Storage location for input content.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GcsSource {
    /// Required. Cloud Storage URIs to input files. Each URI can be up to
    /// 2000 characters long. URIs can match the full object path (for example,
    /// `gs://bucket/directory/object.json`) or a pattern matching one or more
    /// files, such as `gs://bucket/directory/*.json`.
    ///
    /// A request can contain at most 100 files (or 100,000 files if `data_schema`
    /// is `content`). Each file can be up to 2 GB (or 100 MB if `data_schema` is
    /// `content`).
    #[prost(string, repeated, tag = "1")]
    pub input_uris: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// The schema to use when parsing the data from the source.
    ///
    /// Supported values for document imports:
    ///
    /// * `document` (default): One JSON
    /// [Document][google.cloud.discoveryengine.v1alpha.Document] per line. Each
    /// document must
    ///    have a valid
    ///    [Document.id][google.cloud.discoveryengine.v1alpha.Document.id].
    /// * `content`: Unstructured data (e.g. PDF, HTML). Each file matched by
    ///    `input_uris` becomes a document, with the ID set to the first 128
    ///    bits of SHA256(URI) encoded as a hex string.
    /// * `custom`: One custom data JSON per row in arbitrary format that conforms
    ///    to the defined [Schema][google.cloud.discoveryengine.v1alpha.Schema] of
    ///    the data store. This can only be used by the GENERIC Data Store vertical.
    /// * `csv`: A CSV file with header conforming to the defined
    /// [Schema][google.cloud.discoveryengine.v1alpha.Schema] of the
    ///    data store. Each entry after the header is imported as a Document.
    ///    This can only be used by the GENERIC Data Store vertical.
    ///
    /// Supported values for user event imports:
    ///
    /// * `user_event` (default): One JSON
    /// [UserEvent][google.cloud.discoveryengine.v1alpha.UserEvent] per line.
    #[prost(string, tag = "2")]
    pub data_schema: ::prost::alloc::string::String,
}
/// BigQuery source import data from.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BigQuerySource {
    /// The project ID or the project number that contains the BigQuery source. Has
    /// a length limit of 128 characters. If not specified, inherits the project
    /// ID from the parent request.
    #[prost(string, tag = "1")]
    pub project_id: ::prost::alloc::string::String,
    /// Required. The BigQuery data set to copy the data from with a length limit
    /// of 1,024 characters.
    #[prost(string, tag = "2")]
    pub dataset_id: ::prost::alloc::string::String,
    /// Required. The BigQuery table to copy the data from with a length limit of
    /// 1,024 characters.
    #[prost(string, tag = "3")]
    pub table_id: ::prost::alloc::string::String,
    /// Intermediate Cloud Storage directory used for the import with a length
    /// limit of 2,000 characters. Can be specified if one wants to have the
    /// BigQuery export to a specific Cloud Storage directory.
    #[prost(string, tag = "4")]
    pub gcs_staging_dir: ::prost::alloc::string::String,
    /// The schema to use when parsing the data from the source.
    ///
    /// Supported values for user event imports:
    ///
    /// * `user_event` (default): One
    /// [UserEvent][google.cloud.discoveryengine.v1alpha.UserEvent] per row.
    ///
    /// Supported values for document imports:
    ///
    /// * `document` (default): One
    /// [Document][google.cloud.discoveryengine.v1alpha.Document] format per
    ///    row. Each document must have a valid
    ///    [Document.id][google.cloud.discoveryengine.v1alpha.Document.id] and one
    ///    of
    ///    [Document.json_data][google.cloud.discoveryengine.v1alpha.Document.json_data]
    ///    or
    ///    [Document.struct_data][google.cloud.discoveryengine.v1alpha.Document.struct_data].
    /// * `custom`: One custom data per row in arbitrary format that conforms to
    ///    the defined [Schema][google.cloud.discoveryengine.v1alpha.Schema] of the
    ///    data store. This can only be used by the GENERIC Data Store vertical.
    #[prost(string, tag = "6")]
    pub data_schema: ::prost::alloc::string::String,
    /// BigQuery table partition info. Leave this empty if the BigQuery table
    /// is not partitioned.
    #[prost(oneof = "big_query_source::Partition", tags = "5")]
    pub partition: ::core::option::Option<big_query_source::Partition>,
}
/// Nested message and enum types in `BigQuerySource`.
pub mod big_query_source {
    /// BigQuery table partition info. Leave this empty if the BigQuery table
    /// is not partitioned.
    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
    pub enum Partition {
        /// BigQuery time partitioned table's _PARTITIONDATE in YYYY-MM-DD format.
        #[prost(message, tag = "5")]
        PartitionDate(super::super::super::super::r#type::Date),
    }
}
/// The Spanner source for importing data
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SpannerSource {
    /// The project ID that contains the Spanner source. Has a length limit of 128
    /// characters. If not specified, inherits the project ID from the parent
    /// request.
    #[prost(string, tag = "1")]
    pub project_id: ::prost::alloc::string::String,
    /// Required. The instance ID of the source Spanner table.
    #[prost(string, tag = "2")]
    pub instance_id: ::prost::alloc::string::String,
    /// Required. The database ID of the source Spanner table.
    #[prost(string, tag = "3")]
    pub database_id: ::prost::alloc::string::String,
    /// Required. The table name of the Spanner database that needs to be imported.
    #[prost(string, tag = "4")]
    pub table_id: ::prost::alloc::string::String,
    /// Whether to apply data boost on Spanner export. Enabling this option will
    /// incur additional cost. More info can be found
    /// [here](<https://cloud.google.com/spanner/docs/databoost/databoost-overview#billing_and_quotas>).
    #[prost(bool, tag = "5")]
    pub enable_data_boost: bool,
}
/// The Bigtable Options object that contains information to support
/// the import.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BigtableOptions {
    /// The field name used for saving row key value in the document. The name has
    /// to match the pattern `[a-zA-Z0-9][a-zA-Z0-9-_]*`.
    #[prost(string, tag = "1")]
    pub key_field_name: ::prost::alloc::string::String,
    /// The mapping from family names to an object that contains column families
    /// level information for the given column family. If a family is not present
    /// in this map it will be ignored.
    #[prost(btree_map = "string, message", tag = "2")]
    pub families: ::prost::alloc::collections::BTreeMap<
        ::prost::alloc::string::String,
        bigtable_options::BigtableColumnFamily,
    >,
}
/// Nested message and enum types in `BigtableOptions`.
pub mod bigtable_options {
    /// The column family of the Bigtable.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct BigtableColumnFamily {
        /// The field name to use for this column family in the document. The
        /// name has to match the pattern `[a-zA-Z0-9][a-zA-Z0-9-_]*`. If not set,
        /// it is parsed from the family name with best effort. However, due to
        /// different naming patterns, field name collisions could happen, where
        /// parsing behavior is undefined.
        #[prost(string, tag = "1")]
        pub field_name: ::prost::alloc::string::String,
        /// The encoding mode of the values when the type is not STRING.
        /// Acceptable encoding values are:
        ///
        /// * `TEXT`: indicates values are alphanumeric text strings.
        /// * `BINARY`: indicates values are encoded using `HBase Bytes.toBytes`
        /// family of functions. This can be overridden for a specific column
        /// by listing that column in `columns` and specifying an encoding for it.
        #[prost(enumeration = "Encoding", tag = "2")]
        pub encoding: i32,
        /// The type of values in this column family.
        /// The values are expected to be encoded using `HBase Bytes.toBytes`
        /// function when the encoding value is set to `BINARY`.
        #[prost(enumeration = "Type", tag = "3")]
        pub r#type: i32,
        /// The list of objects that contains column level information for each
        /// column. If a column is not present in this list it will be ignored.
        #[prost(message, repeated, tag = "4")]
        pub columns: ::prost::alloc::vec::Vec<BigtableColumn>,
    }
    /// The column of the Bigtable.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct BigtableColumn {
        /// Required. Qualifier of the column. If it cannot be decoded with utf-8,
        /// use a base-64 encoded string instead.
        #[prost(bytes = "bytes", tag = "1")]
        pub qualifier: ::prost::bytes::Bytes,
        /// The field name to use for this column in the document. The name has to
        /// match the pattern `[a-zA-Z0-9][a-zA-Z0-9-_]*`.
        /// If not set, it is parsed from the qualifier bytes with best effort.
        /// However, due to different naming patterns, field name collisions could
        /// happen, where parsing behavior is undefined.
        #[prost(string, tag = "2")]
        pub field_name: ::prost::alloc::string::String,
        /// The encoding mode of the values when the type is not `STRING`.
        /// Acceptable encoding values are:
        ///
        /// * `TEXT`: indicates values are alphanumeric text strings.
        /// * `BINARY`: indicates values are encoded using `HBase Bytes.toBytes`
        /// family of functions. This can be overridden for a specific column
        /// by listing that column in `columns` and specifying an encoding for it.
        #[prost(enumeration = "Encoding", tag = "3")]
        pub encoding: i32,
        /// The type of values in this column family.
        /// The values are expected to be encoded using `HBase Bytes.toBytes`
        /// function when the encoding value is set to `BINARY`.
        #[prost(enumeration = "Type", tag = "4")]
        pub r#type: i32,
    }
    /// The type of values in a Bigtable column or column family.
    /// The values are expected to be encoded using
    /// [HBase
    /// Bytes.toBytes](<https://hbase.apache.org/apidocs/org/apache/hadoop/hbase/util/Bytes.html>)
    /// function when the encoding value is set to `BINARY`.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Type {
        /// The type is unspecified.
        Unspecified = 0,
        /// String type.
        String = 1,
        /// Numerical type.
        Number = 2,
        /// Integer type.
        Integer = 3,
        /// Variable length integer type.
        VarInteger = 4,
        /// BigDecimal type.
        BigNumeric = 5,
        /// Boolean type.
        Boolean = 6,
        /// JSON type.
        Json = 7,
    }
    impl Type {
        /// 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 {
                Type::Unspecified => "TYPE_UNSPECIFIED",
                Type::String => "STRING",
                Type::Number => "NUMBER",
                Type::Integer => "INTEGER",
                Type::VarInteger => "VAR_INTEGER",
                Type::BigNumeric => "BIG_NUMERIC",
                Type::Boolean => "BOOLEAN",
                Type::Json => "JSON",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "STRING" => Some(Self::String),
                "NUMBER" => Some(Self::Number),
                "INTEGER" => Some(Self::Integer),
                "VAR_INTEGER" => Some(Self::VarInteger),
                "BIG_NUMERIC" => Some(Self::BigNumeric),
                "BOOLEAN" => Some(Self::Boolean),
                "JSON" => Some(Self::Json),
                _ => None,
            }
        }
    }
    /// The encoding mode of a Bigtable column or column family.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Encoding {
        /// The encoding is unspecified.
        Unspecified = 0,
        /// Text encoding.
        Text = 1,
        /// Binary encoding.
        Binary = 2,
    }
    impl Encoding {
        /// 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 {
                Encoding::Unspecified => "ENCODING_UNSPECIFIED",
                Encoding::Text => "TEXT",
                Encoding::Binary => "BINARY",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "ENCODING_UNSPECIFIED" => Some(Self::Unspecified),
                "TEXT" => Some(Self::Text),
                "BINARY" => Some(Self::Binary),
                _ => None,
            }
        }
    }
}
/// The Cloud Bigtable source for importing data.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BigtableSource {
    /// The project ID that contains the Bigtable source. Has a length limit of 128
    /// characters. If not specified, inherits the project ID from the parent
    /// request.
    #[prost(string, tag = "1")]
    pub project_id: ::prost::alloc::string::String,
    /// Required. The instance ID of the Cloud Bigtable that needs to be imported.
    #[prost(string, tag = "2")]
    pub instance_id: ::prost::alloc::string::String,
    /// Required. The table ID of the Cloud Bigtable that needs to be imported.
    #[prost(string, tag = "3")]
    pub table_id: ::prost::alloc::string::String,
    /// Required. Bigtable options that contains information needed when parsing
    /// data into typed structures. For example, column type annotations.
    #[prost(message, optional, tag = "4")]
    pub bigtable_options: ::core::option::Option<BigtableOptions>,
}
/// Cloud FhirStore source import data from.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FhirStoreSource {
    /// Required. The full resource name of the FHIR store to import data from, in
    /// the format of
    /// `projects/{project}/locations/{location}/datasets/{dataset}/fhirStores/{fhir_store}`.
    #[prost(string, tag = "1")]
    pub fhir_store: ::prost::alloc::string::String,
    /// Intermediate Cloud Storage directory used for the import with a length
    /// limit of 2,000 characters. Can be specified if one wants to have the
    /// FhirStore export to a specific Cloud Storage directory.
    #[prost(string, tag = "2")]
    pub gcs_staging_dir: ::prost::alloc::string::String,
    /// The FHIR resource types to import. The resource types should be a subset of
    /// all [supported FHIR resource
    /// types](<https://cloud.google.com/generative-ai-app-builder/docs/fhir-schema-reference#resource-level-specification>).
    /// Default to all supported FHIR resource types if empty.
    #[prost(string, repeated, tag = "3")]
    pub resource_types: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Cloud SQL source import data from.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CloudSqlSource {
    /// The project ID that contains the Cloud SQL source. Has a length limit of
    /// 128 characters. If not specified, inherits the project ID from the parent
    /// request.
    #[prost(string, tag = "1")]
    pub project_id: ::prost::alloc::string::String,
    /// Required. The Cloud SQL instance to copy the data from with a length limit
    /// of 256 characters.
    #[prost(string, tag = "2")]
    pub instance_id: ::prost::alloc::string::String,
    /// Required. The Cloud SQL database to copy the data from with a length limit
    /// of 256 characters.
    #[prost(string, tag = "3")]
    pub database_id: ::prost::alloc::string::String,
    /// Required. The Cloud SQL table to copy the data from with a length limit of
    /// 256 characters.
    #[prost(string, tag = "4")]
    pub table_id: ::prost::alloc::string::String,
    /// Intermediate Cloud Storage directory used for the import with a length
    /// limit of 2,000 characters. Can be specified if one wants to have the
    /// Cloud SQL export to a specific Cloud Storage directory.
    ///
    /// Ensure that the Cloud SQL service account has the necessary Cloud
    /// Storage Admin permissions to access the specified Cloud Storage directory.
    #[prost(string, tag = "5")]
    pub gcs_staging_dir: ::prost::alloc::string::String,
    /// Option for serverless export. Enabling this option will incur additional
    /// cost. More info can be found
    /// [here](<https://cloud.google.com/sql/pricing#serverless>).
    #[prost(bool, tag = "6")]
    pub offload: bool,
}
/// AlloyDB source import data from.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AlloyDbSource {
    /// The project ID that contains the AlloyDB source.
    /// Has a length limit of 128 characters. If not specified, inherits the
    /// project ID from the parent request.
    #[prost(string, tag = "1")]
    pub project_id: ::prost::alloc::string::String,
    /// Required. The AlloyDB location to copy the data from with a length limit of
    /// 256 characters.
    #[prost(string, tag = "2")]
    pub location_id: ::prost::alloc::string::String,
    /// Required. The AlloyDB cluster to copy the data from with a length limit of
    /// 256 characters.
    #[prost(string, tag = "3")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Required. The AlloyDB database to copy the data from with a length limit of
    /// 256 characters.
    #[prost(string, tag = "4")]
    pub database_id: ::prost::alloc::string::String,
    /// Required. The AlloyDB table to copy the data from with a length limit of
    /// 256 characters.
    #[prost(string, tag = "5")]
    pub table_id: ::prost::alloc::string::String,
    /// Intermediate Cloud Storage directory used for the import with a length
    /// limit of 2,000 characters. Can be specified if one wants to have the
    /// AlloyDB export to a specific Cloud Storage directory.
    ///
    /// Ensure that the AlloyDB service account has the necessary Cloud
    /// Storage Admin permissions to access the specified Cloud Storage directory.
    #[prost(string, tag = "6")]
    pub gcs_staging_dir: ::prost::alloc::string::String,
}
/// Firestore source import data from.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FirestoreSource {
    /// The project ID that the Cloud SQL source is in with a length limit of 128
    /// characters. If not specified, inherits the project ID from the parent
    /// request.
    #[prost(string, tag = "1")]
    pub project_id: ::prost::alloc::string::String,
    /// Required. The Firestore database to copy the data from with a length limit
    /// of 256 characters.
    #[prost(string, tag = "2")]
    pub database_id: ::prost::alloc::string::String,
    /// Required. The Firestore collection (or entity) to copy the data from with a
    /// length limit of 1,500 characters.
    #[prost(string, tag = "3")]
    pub collection_id: ::prost::alloc::string::String,
    /// Intermediate Cloud Storage directory used for the import with a length
    /// limit of 2,000 characters. Can be specified if one wants to have the
    /// Firestore export to a specific Cloud Storage directory.
    ///
    /// Ensure that the Firestore service account has the necessary Cloud
    /// Storage Admin permissions to access the specified Cloud Storage directory.
    #[prost(string, tag = "4")]
    pub gcs_staging_dir: ::prost::alloc::string::String,
}
/// Configuration of destination for Import related errors.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ImportErrorConfig {
    /// Required. Errors destination.
    #[prost(oneof = "import_error_config::Destination", tags = "1")]
    pub destination: ::core::option::Option<import_error_config::Destination>,
}
/// Nested message and enum types in `ImportErrorConfig`.
pub mod import_error_config {
    /// Required. Errors destination.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Destination {
        /// Cloud Storage prefix for import errors. This must be an empty,
        /// existing Cloud Storage directory. Import errors are written to
        /// sharded files in this directory, one per line, as a JSON-encoded
        /// `google.rpc.Status` message.
        #[prost(string, tag = "1")]
        GcsPrefix(::prost::alloc::string::String),
    }
}
/// Request message for the ImportUserEvents request.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ImportUserEventsRequest {
    /// Required. Parent DataStore resource name, of the form
    /// `projects/{project}/locations/{location}/collections/{collection}/dataStores/{data_store}`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The desired location of errors incurred during the Import. Cannot be set
    /// for inline user event imports.
    #[prost(message, optional, tag = "5")]
    pub error_config: ::core::option::Option<ImportErrorConfig>,
    /// Required - The desired input source of the user event data.
    #[prost(oneof = "import_user_events_request::Source", tags = "2, 3, 4")]
    pub source: ::core::option::Option<import_user_events_request::Source>,
}
/// Nested message and enum types in `ImportUserEventsRequest`.
pub mod import_user_events_request {
    /// The inline source for the input config for ImportUserEvents method.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct InlineSource {
        /// Required. A list of user events to import. Recommended max of 10k items.
        #[prost(message, repeated, tag = "1")]
        pub user_events: ::prost::alloc::vec::Vec<super::UserEvent>,
    }
    /// Required - The desired input source of the user event data.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Source {
        /// The Inline source for the input content for UserEvents.
        #[prost(message, tag = "2")]
        InlineSource(InlineSource),
        /// Cloud Storage location for the input content.
        #[prost(message, tag = "3")]
        GcsSource(super::GcsSource),
        /// BigQuery input source.
        #[prost(message, tag = "4")]
        BigquerySource(super::BigQuerySource),
    }
}
/// Response of the ImportUserEventsRequest. If the long running
/// operation was successful, then this message is returned by the
/// google.longrunning.Operations.response field if the operation was successful.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ImportUserEventsResponse {
    /// A sample of errors encountered while processing the request.
    #[prost(message, repeated, tag = "1")]
    pub error_samples: ::prost::alloc::vec::Vec<super::super::super::rpc::Status>,
    /// Echoes the destination for the complete errors if this field was set in
    /// the request.
    #[prost(message, optional, tag = "2")]
    pub error_config: ::core::option::Option<ImportErrorConfig>,
    /// Count of user events imported with complete existing Documents.
    #[prost(int64, tag = "3")]
    pub joined_events_count: i64,
    /// Count of user events imported, but with Document information not found
    /// in the existing Branch.
    #[prost(int64, tag = "4")]
    pub unjoined_events_count: i64,
}
/// Metadata related to the progress of the Import operation. This is
/// returned by the google.longrunning.Operation.metadata field.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ImportUserEventsMetadata {
    /// Operation create time.
    #[prost(message, optional, tag = "1")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Operation last update time. If the operation is done, this is also the
    /// finish time.
    #[prost(message, optional, tag = "2")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Count of entries that were processed successfully.
    #[prost(int64, tag = "3")]
    pub success_count: i64,
    /// Count of entries that encountered errors while processing.
    #[prost(int64, tag = "4")]
    pub failure_count: i64,
}
/// Metadata related to the progress of the ImportDocuments operation. This is
/// returned by the google.longrunning.Operation.metadata field.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ImportDocumentsMetadata {
    /// Operation create time.
    #[prost(message, optional, tag = "1")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Operation last update time. If the operation is done, this is also the
    /// finish time.
    #[prost(message, optional, tag = "2")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Count of entries that were processed successfully.
    #[prost(int64, tag = "3")]
    pub success_count: i64,
    /// Count of entries that encountered errors while processing.
    #[prost(int64, tag = "4")]
    pub failure_count: i64,
    /// Total count of entries that were processed.
    #[prost(int64, tag = "5")]
    pub total_count: i64,
}
/// Request message for Import methods.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ImportDocumentsRequest {
    /// Required. The parent branch resource name, such as
    /// `projects/{project}/locations/{location}/collections/{collection}/dataStores/{data_store}/branches/{branch}`.
    /// Requires create/update permission.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The desired location of errors incurred during the Import.
    #[prost(message, optional, tag = "5")]
    pub error_config: ::core::option::Option<ImportErrorConfig>,
    /// The mode of reconciliation between existing documents and the documents to
    /// be imported. Defaults to
    /// [ReconciliationMode.INCREMENTAL][google.cloud.discoveryengine.v1alpha.ImportDocumentsRequest.ReconciliationMode.INCREMENTAL].
    #[prost(enumeration = "import_documents_request::ReconciliationMode", tag = "6")]
    pub reconciliation_mode: i32,
    /// Indicates which fields in the provided imported documents to update. If
    /// not set, the default is to update all fields.
    #[prost(message, optional, tag = "7")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// Whether to automatically generate IDs for the documents if absent.
    ///
    /// If set to `true`,
    /// [Document.id][google.cloud.discoveryengine.v1alpha.Document.id]s are
    /// automatically generated based on the hash of the payload, where IDs may not
    /// be consistent during multiple imports. In which case
    /// [ReconciliationMode.FULL][google.cloud.discoveryengine.v1alpha.ImportDocumentsRequest.ReconciliationMode.FULL]
    /// is highly recommended to avoid duplicate contents. If unset or set to
    /// `false`, [Document.id][google.cloud.discoveryengine.v1alpha.Document.id]s
    /// have to be specified using
    /// [id_field][google.cloud.discoveryengine.v1alpha.ImportDocumentsRequest.id_field],
    /// otherwise, documents without IDs fail to be imported.
    ///
    /// Supported data sources:
    ///
    /// * [GcsSource][google.cloud.discoveryengine.v1alpha.GcsSource].
    /// [GcsSource.data_schema][google.cloud.discoveryengine.v1alpha.GcsSource.data_schema]
    /// must be `custom` or `csv`. Otherwise, an INVALID_ARGUMENT error is thrown.
    /// * [BigQuerySource][google.cloud.discoveryengine.v1alpha.BigQuerySource].
    /// [BigQuerySource.data_schema][google.cloud.discoveryengine.v1alpha.BigQuerySource.data_schema]
    /// must be `custom` or `csv`. Otherwise, an INVALID_ARGUMENT error is thrown.
    /// * [SpannerSource][google.cloud.discoveryengine.v1alpha.SpannerSource].
    /// * [CloudSqlSource][google.cloud.discoveryengine.v1alpha.CloudSqlSource].
    /// * [FirestoreSource][google.cloud.discoveryengine.v1alpha.FirestoreSource].
    /// * [BigtableSource][google.cloud.discoveryengine.v1alpha.BigtableSource].
    #[prost(bool, tag = "8")]
    pub auto_generate_ids: bool,
    /// The field indicates the ID field or column to be used as unique IDs of
    /// the documents.
    ///
    /// For [GcsSource][google.cloud.discoveryengine.v1alpha.GcsSource] it is the
    /// key of the JSON field. For instance, `my_id` for JSON `{"my_id":
    /// "some_uuid"}`. For others, it may be the column name of the table where the
    /// unique ids are stored.
    ///
    /// The values of the JSON field or the table column are used as the
    /// [Document.id][google.cloud.discoveryengine.v1alpha.Document.id]s. The JSON
    /// field or the table column must be of string type, and the values must be
    /// set as valid strings conform to
    /// [RFC-1034](<https://tools.ietf.org/html/rfc1034>) with 1-63 characters.
    /// Otherwise, documents without valid IDs fail to be imported.
    ///
    /// Only set this field when
    /// [auto_generate_ids][google.cloud.discoveryengine.v1alpha.ImportDocumentsRequest.auto_generate_ids]
    /// is unset or set as `false`. Otherwise, an INVALID_ARGUMENT error is thrown.
    ///
    /// If it is unset, a default value `_id` is used when importing from the
    /// allowed data sources.
    ///
    /// Supported data sources:
    ///
    /// * [GcsSource][google.cloud.discoveryengine.v1alpha.GcsSource].
    /// [GcsSource.data_schema][google.cloud.discoveryengine.v1alpha.GcsSource.data_schema]
    /// must be `custom` or `csv`. Otherwise, an INVALID_ARGUMENT error is thrown.
    /// * [BigQuerySource][google.cloud.discoveryengine.v1alpha.BigQuerySource].
    /// [BigQuerySource.data_schema][google.cloud.discoveryengine.v1alpha.BigQuerySource.data_schema]
    /// must be `custom` or `csv`. Otherwise, an INVALID_ARGUMENT error is thrown.
    /// * [SpannerSource][google.cloud.discoveryengine.v1alpha.SpannerSource].
    /// * [CloudSqlSource][google.cloud.discoveryengine.v1alpha.CloudSqlSource].
    /// * [FirestoreSource][google.cloud.discoveryengine.v1alpha.FirestoreSource].
    /// * [BigtableSource][google.cloud.discoveryengine.v1alpha.BigtableSource].
    #[prost(string, tag = "9")]
    pub id_field: ::prost::alloc::string::String,
    /// Required. The source of the input.
    #[prost(
        oneof = "import_documents_request::Source",
        tags = "2, 3, 4, 10, 11, 12, 13, 14, 15"
    )]
    pub source: ::core::option::Option<import_documents_request::Source>,
}
/// Nested message and enum types in `ImportDocumentsRequest`.
pub mod import_documents_request {
    /// The inline source for the input config for ImportDocuments method.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct InlineSource {
        /// Required. A list of documents to update/create. Each document must have a
        /// valid [Document.id][google.cloud.discoveryengine.v1alpha.Document.id].
        /// Recommended max of 100 items.
        #[prost(message, repeated, tag = "1")]
        pub documents: ::prost::alloc::vec::Vec<super::Document>,
    }
    /// Indicates how imported documents are reconciled with the existing documents
    /// created or imported before.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ReconciliationMode {
        /// Defaults to `INCREMENTAL`.
        Unspecified = 0,
        /// Inserts new documents or updates existing documents.
        Incremental = 1,
        /// Calculates diff and replaces the entire document dataset. Existing
        /// documents may be deleted if they are not present in the source location.
        Full = 2,
    }
    impl ReconciliationMode {
        /// 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 {
                ReconciliationMode::Unspecified => "RECONCILIATION_MODE_UNSPECIFIED",
                ReconciliationMode::Incremental => "INCREMENTAL",
                ReconciliationMode::Full => "FULL",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "RECONCILIATION_MODE_UNSPECIFIED" => Some(Self::Unspecified),
                "INCREMENTAL" => Some(Self::Incremental),
                "FULL" => Some(Self::Full),
                _ => None,
            }
        }
    }
    /// Required. The source of the input.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Source {
        /// The Inline source for the input content for documents.
        #[prost(message, tag = "2")]
        InlineSource(InlineSource),
        /// Cloud Storage location for the input content.
        #[prost(message, tag = "3")]
        GcsSource(super::GcsSource),
        /// BigQuery input source.
        #[prost(message, tag = "4")]
        BigquerySource(super::BigQuerySource),
        /// FhirStore input source.
        #[prost(message, tag = "10")]
        FhirStoreSource(super::FhirStoreSource),
        /// Spanner input source.
        #[prost(message, tag = "11")]
        SpannerSource(super::SpannerSource),
        /// Cloud SQL input source.
        #[prost(message, tag = "12")]
        CloudSqlSource(super::CloudSqlSource),
        /// Firestore input source.
        #[prost(message, tag = "13")]
        FirestoreSource(super::FirestoreSource),
        /// AlloyDB input source.
        #[prost(message, tag = "14")]
        AlloyDbSource(super::AlloyDbSource),
        /// Cloud Bigtable input source.
        #[prost(message, tag = "15")]
        BigtableSource(super::BigtableSource),
    }
}
/// Response of the
/// [ImportDocumentsRequest][google.cloud.discoveryengine.v1alpha.ImportDocumentsRequest].
/// If the long running operation is done, then this message is returned by the
/// google.longrunning.Operations.response field if the operation was successful.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ImportDocumentsResponse {
    /// A sample of errors encountered while processing the request.
    #[prost(message, repeated, tag = "1")]
    pub error_samples: ::prost::alloc::vec::Vec<super::super::super::rpc::Status>,
    /// Echoes the destination for the complete errors in the request if set.
    #[prost(message, optional, tag = "2")]
    pub error_config: ::core::option::Option<ImportErrorConfig>,
}
/// Request message for
/// [CompletionService.ImportSuggestionDenyListEntries][google.cloud.discoveryengine.v1alpha.CompletionService.ImportSuggestionDenyListEntries]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ImportSuggestionDenyListEntriesRequest {
    /// Required. The parent data store resource name for which to import denylist
    /// entries. Follows pattern projects/*/locations/*/collections/*/dataStores/*.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The source of the updated SuggestionDenyList.
    #[prost(
        oneof = "import_suggestion_deny_list_entries_request::Source",
        tags = "2, 3"
    )]
    pub source: ::core::option::Option<
        import_suggestion_deny_list_entries_request::Source,
    >,
}
/// Nested message and enum types in `ImportSuggestionDenyListEntriesRequest`.
pub mod import_suggestion_deny_list_entries_request {
    /// The inline source for SuggestionDenyListEntry.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct InlineSource {
        /// Required. A list of all denylist entries to import. Max of 1000 items.
        #[prost(message, repeated, tag = "1")]
        pub entries: ::prost::alloc::vec::Vec<super::SuggestionDenyListEntry>,
    }
    /// The source of the updated SuggestionDenyList.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Source {
        /// The Inline source for the input content for suggestion deny list entries.
        #[prost(message, tag = "2")]
        InlineSource(InlineSource),
        /// Cloud Storage location for the input content.
        ///
        /// Only 1 file can be specified that contains all entries to import.
        /// Supported values `gcs_source.schema` for autocomplete suggestion deny
        /// list entry imports:
        ///
        /// * `suggestion_deny_list` (default): One JSON \[SuggestionDenyListEntry\]
        /// per line.
        #[prost(message, tag = "3")]
        GcsSource(super::GcsSource),
    }
}
/// Response message for
/// [CompletionService.ImportSuggestionDenyListEntries][google.cloud.discoveryengine.v1alpha.CompletionService.ImportSuggestionDenyListEntries]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ImportSuggestionDenyListEntriesResponse {
    /// A sample of errors encountered while processing the request.
    #[prost(message, repeated, tag = "1")]
    pub error_samples: ::prost::alloc::vec::Vec<super::super::super::rpc::Status>,
    /// Count of deny list entries successfully imported.
    #[prost(int64, tag = "2")]
    pub imported_entries_count: i64,
    /// Count of deny list entries that failed to be imported.
    #[prost(int64, tag = "3")]
    pub failed_entries_count: i64,
}
/// Metadata related to the progress of the ImportSuggestionDenyListEntries
/// operation. This is returned by the google.longrunning.Operation.metadata
/// field.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ImportSuggestionDenyListEntriesMetadata {
    /// Operation create time.
    #[prost(message, optional, tag = "1")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Operation last update time. If the operation is done, this is also the
    /// finish time.
    #[prost(message, optional, tag = "2")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Request message for
/// [CompletionService.ImportCompletionSuggestions][google.cloud.discoveryengine.v1alpha.CompletionService.ImportCompletionSuggestions]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ImportCompletionSuggestionsRequest {
    /// Required. The parent data store resource name for which to import customer
    /// autocomplete suggestions.
    ///
    /// Follows pattern `projects/*/locations/*/collections/*/dataStores/*`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The desired location of errors incurred during the Import.
    #[prost(message, optional, tag = "5")]
    pub error_config: ::core::option::Option<ImportErrorConfig>,
    /// The source of the autocomplete suggestions.
    #[prost(oneof = "import_completion_suggestions_request::Source", tags = "2, 3, 4")]
    pub source: ::core::option::Option<import_completion_suggestions_request::Source>,
}
/// Nested message and enum types in `ImportCompletionSuggestionsRequest`.
pub mod import_completion_suggestions_request {
    /// The inline source for CompletionSuggestions.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct InlineSource {
        /// Required. A list of all denylist entries to import. Max of 1000 items.
        #[prost(message, repeated, tag = "1")]
        pub suggestions: ::prost::alloc::vec::Vec<super::CompletionSuggestion>,
    }
    /// The source of the autocomplete suggestions.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Source {
        /// The Inline source for suggestion entries.
        #[prost(message, tag = "2")]
        InlineSource(InlineSource),
        /// Cloud Storage location for the input content.
        #[prost(message, tag = "3")]
        GcsSource(super::GcsSource),
        /// BigQuery input source.
        #[prost(message, tag = "4")]
        BigquerySource(super::BigQuerySource),
    }
}
/// Response of the
/// [CompletionService.ImportCompletionSuggestions][google.cloud.discoveryengine.v1alpha.CompletionService.ImportCompletionSuggestions]
/// method. If the long running operation is done, this message is returned by
/// the google.longrunning.Operations.response field if the operation is
/// successful.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ImportCompletionSuggestionsResponse {
    /// A sample of errors encountered while processing the request.
    #[prost(message, repeated, tag = "1")]
    pub error_samples: ::prost::alloc::vec::Vec<super::super::super::rpc::Status>,
    /// The desired location of errors incurred during the Import.
    #[prost(message, optional, tag = "2")]
    pub error_config: ::core::option::Option<ImportErrorConfig>,
}
/// Metadata related to the progress of the ImportCompletionSuggestions
/// operation. This will be returned by the google.longrunning.Operation.metadata
/// field.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ImportCompletionSuggestionsMetadata {
    /// Operation create time.
    #[prost(message, optional, tag = "1")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Operation last update time. If the operation is done, this is also the
    /// finish time.
    #[prost(message, optional, tag = "2")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Count of
    /// [CompletionSuggestion][google.cloud.discoveryengine.v1alpha.CompletionSuggestion]s
    /// successfully imported.
    #[prost(int64, tag = "3")]
    pub success_count: i64,
    /// Count of
    /// [CompletionSuggestion][google.cloud.discoveryengine.v1alpha.CompletionSuggestion]s
    /// that failed to be imported.
    #[prost(int64, tag = "4")]
    pub failure_count: i64,
}
/// Request message for
/// [SampleQueryService.ImportSampleQueries][google.cloud.discoveryengine.v1alpha.SampleQueryService.ImportSampleQueries]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ImportSampleQueriesRequest {
    /// Required. The parent sample query set resource name, such as
    /// `projects/{project}/locations/{location}/sampleQuerySets/{sampleQuerySet}`.
    ///
    /// If the caller does not have permission to list
    /// [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery]s under this
    /// sample query set, regardless of whether or not this sample query set
    /// exists, a `PERMISSION_DENIED` error is returned.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The desired location of errors incurred during the Import.
    #[prost(message, optional, tag = "5")]
    pub error_config: ::core::option::Option<ImportErrorConfig>,
    /// The source of the sample queries.
    #[prost(oneof = "import_sample_queries_request::Source", tags = "2, 3, 4")]
    pub source: ::core::option::Option<import_sample_queries_request::Source>,
}
/// Nested message and enum types in `ImportSampleQueriesRequest`.
pub mod import_sample_queries_request {
    /// The inline source for
    /// [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery]s.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct InlineSource {
        /// Required. A list of
        /// [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery]s to
        /// import. Max of 1000 items.
        #[prost(message, repeated, tag = "1")]
        pub sample_queries: ::prost::alloc::vec::Vec<super::SampleQuery>,
    }
    /// The source of the sample queries.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Source {
        /// The Inline source for sample query entries.
        #[prost(message, tag = "2")]
        InlineSource(InlineSource),
        /// Cloud Storage location for the input content.
        #[prost(message, tag = "3")]
        GcsSource(super::GcsSource),
        /// BigQuery input source.
        #[prost(message, tag = "4")]
        BigquerySource(super::BigQuerySource),
    }
}
/// Response of the
/// [SampleQueryService.ImportSampleQueries][google.cloud.discoveryengine.v1alpha.SampleQueryService.ImportSampleQueries]
/// method. If the long running operation is done, this message is returned by
/// the google.longrunning.Operations.response field if the operation is
/// successful.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ImportSampleQueriesResponse {
    /// A sample of errors encountered while processing the request.
    #[prost(message, repeated, tag = "1")]
    pub error_samples: ::prost::alloc::vec::Vec<super::super::super::rpc::Status>,
    /// The desired location of errors incurred during the Import.
    #[prost(message, optional, tag = "2")]
    pub error_config: ::core::option::Option<ImportErrorConfig>,
}
/// Metadata related to the progress of the ImportSampleQueries
/// operation. This will be returned by the google.longrunning.Operation.metadata
/// field.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ImportSampleQueriesMetadata {
    /// ImportSampleQueries operation create time.
    #[prost(message, optional, tag = "1")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// ImportSampleQueries operation last update time. If the operation is done,
    /// this is also the finish time.
    #[prost(message, optional, tag = "2")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Count of [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery]s
    /// successfully imported.
    #[prost(int64, tag = "3")]
    pub success_count: i64,
    /// Count of [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery]s
    /// that failed to be imported.
    #[prost(int64, tag = "4")]
    pub failure_count: i64,
    /// Total count of
    /// [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery]s that were
    /// processed.
    #[prost(int64, tag = "5")]
    pub total_count: i64,
}
/// Request message for PurgeUserEvents method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PurgeUserEventsRequest {
    /// Required. The resource name of the catalog under which the events are
    /// created. The format is
    /// `projects/${projectId}/locations/global/collections/{$collectionId}/dataStores/${dataStoreId}`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The filter string to specify the events to be deleted with a
    /// length limit of 5,000 characters. The eligible fields for filtering are:
    ///
    /// * `eventType`: Double quoted
    /// [UserEvent.event_type][google.cloud.discoveryengine.v1alpha.UserEvent.event_type]
    /// string.
    /// * `eventTime`: in ISO 8601 "zulu" format.
    /// * `userPseudoId`: Double quoted string. Specifying this will delete all
    ///    events associated with a visitor.
    /// * `userId`: Double quoted string. Specifying this will delete all events
    ///    associated with a user.
    ///
    /// Examples:
    ///
    /// * Deleting all events in a time range:
    ///    `eventTime > "2012-04-23T18:25:43.511Z"
    ///    eventTime < "2012-04-23T18:30:43.511Z"`
    /// * Deleting specific eventType:
    ///    `eventType = "search"`
    /// * Deleting all events for a specific visitor:
    ///    `userPseudoId = "visitor1024"`
    /// * Deleting all events inside a DataStore:
    ///    `*`
    ///
    /// The filtering fields are assumed to have an implicit AND.
    #[prost(string, tag = "2")]
    pub filter: ::prost::alloc::string::String,
    /// The `force` field is currently not supported. Purge user event requests
    /// will permanently delete all purgeable events. Once the development is
    /// complete:
    /// If `force` is set to false, the method will return the expected
    /// purge count without deleting any user events. This field will default to
    /// false if not included in the request.
    #[prost(bool, tag = "3")]
    pub force: bool,
}
/// Response of the PurgeUserEventsRequest. If the long running operation is
/// successfully done, then this message is returned by the
/// google.longrunning.Operations.response field.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct PurgeUserEventsResponse {
    /// The total count of events purged as a result of the operation.
    #[prost(int64, tag = "1")]
    pub purge_count: i64,
}
/// Metadata related to the progress of the PurgeUserEvents operation.
/// This will be returned by the google.longrunning.Operation.metadata field.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct PurgeUserEventsMetadata {
    /// Operation create time.
    #[prost(message, optional, tag = "1")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Operation last update time. If the operation is done, this is also the
    /// finish time.
    #[prost(message, optional, tag = "2")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Count of entries that were deleted successfully.
    #[prost(int64, tag = "3")]
    pub success_count: i64,
    /// Count of entries that encountered errors while processing.
    #[prost(int64, tag = "4")]
    pub failure_count: i64,
}
/// Configuration of destination for Purge related errors.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PurgeErrorConfig {
    /// Required. Errors destination.
    #[prost(oneof = "purge_error_config::Destination", tags = "1")]
    pub destination: ::core::option::Option<purge_error_config::Destination>,
}
/// Nested message and enum types in `PurgeErrorConfig`.
pub mod purge_error_config {
    /// Required. Errors destination.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Destination {
        /// Cloud Storage prefix for purge errors. This must be an empty,
        /// existing Cloud Storage directory. Purge errors are written to
        /// sharded files in this directory, one per line, as a JSON-encoded
        /// `google.rpc.Status` message.
        #[prost(string, tag = "1")]
        GcsPrefix(::prost::alloc::string::String),
    }
}
/// Request message for
/// [DocumentService.PurgeDocuments][google.cloud.discoveryengine.v1alpha.DocumentService.PurgeDocuments]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PurgeDocumentsRequest {
    /// Required. The parent resource name, such as
    /// `projects/{project}/locations/{location}/collections/{collection}/dataStores/{data_store}/branches/{branch}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. Filter matching documents to purge. Only currently supported
    /// value is
    /// `*` (all items).
    #[prost(string, tag = "2")]
    pub filter: ::prost::alloc::string::String,
    /// The desired location of errors incurred during the purge.
    #[prost(message, optional, tag = "7")]
    pub error_config: ::core::option::Option<PurgeErrorConfig>,
    /// Actually performs the purge. If `force` is set to false, return the
    /// expected purge count without deleting any documents.
    #[prost(bool, tag = "3")]
    pub force: bool,
    /// The desired input source for the purging documents based on document IDs.
    #[prost(oneof = "purge_documents_request::Source", tags = "5, 6")]
    pub source: ::core::option::Option<purge_documents_request::Source>,
}
/// Nested message and enum types in `PurgeDocumentsRequest`.
pub mod purge_documents_request {
    /// The inline source for the input config for
    /// [DocumentService.PurgeDocuments][google.cloud.discoveryengine.v1alpha.DocumentService.PurgeDocuments]
    /// method.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct InlineSource {
        /// Required. A list of full resource name of documents to purge. In the
        /// format
        /// `projects/*/locations/*/collections/*/dataStores/*/branches/*/documents/*`.
        /// Recommended max of 100 items.
        #[prost(string, repeated, tag = "1")]
        pub documents: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    }
    /// The desired input source for the purging documents based on document IDs.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Source {
        /// Cloud Storage location for the input content.
        /// Supported `data_schema`:
        /// * `document_id`: One valid
        /// [Document.id][google.cloud.discoveryengine.v1alpha.Document.id] per line.
        #[prost(message, tag = "5")]
        GcsSource(super::GcsSource),
        /// Inline source for the input content for purge.
        #[prost(message, tag = "6")]
        InlineSource(InlineSource),
    }
}
/// Response message for
/// [DocumentService.PurgeDocuments][google.cloud.discoveryengine.v1alpha.DocumentService.PurgeDocuments]
/// method. If the long running operation is successfully done, then this message
/// is returned by the google.longrunning.Operations.response field.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PurgeDocumentsResponse {
    /// The total count of documents purged as a result of the operation.
    #[prost(int64, tag = "1")]
    pub purge_count: i64,
    /// A sample of document names that will be deleted. Only populated if `force`
    /// is set to false. A max of 100 names will be returned and the names are
    /// chosen at random.
    #[prost(string, repeated, tag = "2")]
    pub purge_sample: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Metadata related to the progress of the PurgeDocuments operation.
/// This will be returned by the google.longrunning.Operation.metadata field.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct PurgeDocumentsMetadata {
    /// Operation create time.
    #[prost(message, optional, tag = "1")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Operation last update time. If the operation is done, this is also the
    /// finish time.
    #[prost(message, optional, tag = "2")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Count of entries that were deleted successfully.
    #[prost(int64, tag = "3")]
    pub success_count: i64,
    /// Count of entries that encountered errors while processing.
    #[prost(int64, tag = "4")]
    pub failure_count: i64,
    /// Count of entries that were ignored as entries were not found.
    #[prost(int64, tag = "5")]
    pub ignored_count: i64,
}
/// Request message for
/// [CompletionService.PurgeSuggestionDenyListEntries][google.cloud.discoveryengine.v1alpha.CompletionService.PurgeSuggestionDenyListEntries]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PurgeSuggestionDenyListEntriesRequest {
    /// Required. The parent data store resource name for which to import denylist
    /// entries. Follows pattern projects/*/locations/*/collections/*/dataStores/*.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
}
/// Response message for
/// [CompletionService.PurgeSuggestionDenyListEntries][google.cloud.discoveryengine.v1alpha.CompletionService.PurgeSuggestionDenyListEntries]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PurgeSuggestionDenyListEntriesResponse {
    /// Number of suggestion deny list entries purged.
    #[prost(int64, tag = "1")]
    pub purge_count: i64,
    /// A sample of errors encountered while processing the request.
    #[prost(message, repeated, tag = "2")]
    pub error_samples: ::prost::alloc::vec::Vec<super::super::super::rpc::Status>,
}
/// Metadata related to the progress of the PurgeSuggestionDenyListEntries
/// operation. This is returned by the google.longrunning.Operation.metadata
/// field.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct PurgeSuggestionDenyListEntriesMetadata {
    /// Operation create time.
    #[prost(message, optional, tag = "1")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Operation last update time. If the operation is done, this is also the
    /// finish time.
    #[prost(message, optional, tag = "2")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Request message for
/// [CompletionService.PurgeCompletionSuggestions][google.cloud.discoveryengine.v1alpha.CompletionService.PurgeCompletionSuggestions]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PurgeCompletionSuggestionsRequest {
    /// Required. The parent data store resource name for which to purge completion
    /// suggestions. Follows pattern
    /// projects/*/locations/*/collections/*/dataStores/*.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
}
/// Response message for
/// [CompletionService.PurgeCompletionSuggestions][google.cloud.discoveryengine.v1alpha.CompletionService.PurgeCompletionSuggestions]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PurgeCompletionSuggestionsResponse {
    /// Whether the completion suggestions were successfully purged.
    #[prost(bool, tag = "1")]
    pub purge_succeeded: bool,
    /// A sample of errors encountered while processing the request.
    #[prost(message, repeated, tag = "2")]
    pub error_samples: ::prost::alloc::vec::Vec<super::super::super::rpc::Status>,
}
/// Metadata related to the progress of the PurgeCompletionSuggestions
/// operation. This is returned by the google.longrunning.Operation.metadata
/// field.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct PurgeCompletionSuggestionsMetadata {
    /// Operation create time.
    #[prost(message, optional, tag = "1")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Operation last update time. If the operation is done, this is also the
    /// finish time.
    #[prost(message, optional, tag = "2")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Request message for
/// [DocumentService.GetDocument][google.cloud.discoveryengine.v1alpha.DocumentService.GetDocument]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetDocumentRequest {
    /// Required. Full resource name of
    /// [Document][google.cloud.discoveryengine.v1alpha.Document], such as
    /// `projects/{project}/locations/{location}/collections/{collection}/dataStores/{data_store}/branches/{branch}/documents/{document}`.
    ///
    /// If the caller does not have permission to access the
    /// [Document][google.cloud.discoveryengine.v1alpha.Document], regardless of
    /// whether or not it exists, a `PERMISSION_DENIED` error is returned.
    ///
    /// If the requested [Document][google.cloud.discoveryengine.v1alpha.Document]
    /// does not exist, a `NOT_FOUND` error is returned.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for
/// [DocumentService.ListDocuments][google.cloud.discoveryengine.v1alpha.DocumentService.ListDocuments]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListDocumentsRequest {
    /// Required. The parent branch resource name, such as
    /// `projects/{project}/locations/{location}/collections/{collection}/dataStores/{data_store}/branches/{branch}`.
    /// Use `default_branch` as the branch ID, to list documents under the default
    /// branch.
    ///
    /// If the caller does not have permission to list
    /// [Document][google.cloud.discoveryengine.v1alpha.Document]s under this
    /// branch, regardless of whether or not this branch exists, a
    /// `PERMISSION_DENIED` error is returned.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Maximum number of
    /// [Document][google.cloud.discoveryengine.v1alpha.Document]s to return. If
    /// unspecified, defaults to 100. The maximum allowed value is 1000. Values
    /// above 1000 are set to 1000.
    ///
    /// If this field is negative, an `INVALID_ARGUMENT` error is returned.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// A page token
    /// [ListDocumentsResponse.next_page_token][google.cloud.discoveryengine.v1alpha.ListDocumentsResponse.next_page_token],
    /// received from a previous
    /// [DocumentService.ListDocuments][google.cloud.discoveryengine.v1alpha.DocumentService.ListDocuments]
    /// call. Provide this to retrieve the subsequent page.
    ///
    /// When paginating, all other parameters provided to
    /// [DocumentService.ListDocuments][google.cloud.discoveryengine.v1alpha.DocumentService.ListDocuments]
    /// must match the call that provided the page token. Otherwise, an
    /// `INVALID_ARGUMENT` error is returned.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// Response message for
/// [DocumentService.ListDocuments][google.cloud.discoveryengine.v1alpha.DocumentService.ListDocuments]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListDocumentsResponse {
    /// The [Document][google.cloud.discoveryengine.v1alpha.Document]s.
    #[prost(message, repeated, tag = "1")]
    pub documents: ::prost::alloc::vec::Vec<Document>,
    /// A token that can be sent as
    /// [ListDocumentsRequest.page_token][google.cloud.discoveryengine.v1alpha.ListDocumentsRequest.page_token]
    /// to retrieve the next page. If this field is omitted, there are no
    /// subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for
/// [DocumentService.CreateDocument][google.cloud.discoveryengine.v1alpha.DocumentService.CreateDocument]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateDocumentRequest {
    /// Required. The parent resource name, such as
    /// `projects/{project}/locations/{location}/collections/{collection}/dataStores/{data_store}/branches/{branch}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The [Document][google.cloud.discoveryengine.v1alpha.Document] to
    /// create.
    #[prost(message, optional, tag = "2")]
    pub document: ::core::option::Option<Document>,
    /// Required. The ID to use for the
    /// [Document][google.cloud.discoveryengine.v1alpha.Document], which becomes
    /// the final component of the
    /// [Document.name][google.cloud.discoveryengine.v1alpha.Document.name].
    ///
    /// If the caller does not have permission to create the
    /// [Document][google.cloud.discoveryengine.v1alpha.Document], regardless of
    /// whether or not it exists, a `PERMISSION_DENIED` error is returned.
    ///
    /// This field must be unique among all
    /// [Document][google.cloud.discoveryengine.v1alpha.Document]s with the same
    /// [parent][google.cloud.discoveryengine.v1alpha.CreateDocumentRequest.parent].
    /// Otherwise, an `ALREADY_EXISTS` error is returned.
    ///
    /// This field must conform to [RFC-1034](<https://tools.ietf.org/html/rfc1034>)
    /// standard with a length limit of 63 characters. Otherwise, an
    /// `INVALID_ARGUMENT` error is returned.
    #[prost(string, tag = "3")]
    pub document_id: ::prost::alloc::string::String,
}
/// Request message for
/// [DocumentService.UpdateDocument][google.cloud.discoveryengine.v1alpha.DocumentService.UpdateDocument]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateDocumentRequest {
    /// Required. The document to update/create.
    ///
    /// If the caller does not have permission to update the
    /// [Document][google.cloud.discoveryengine.v1alpha.Document], regardless of
    /// whether or not it exists, a `PERMISSION_DENIED` error is returned.
    ///
    /// If the [Document][google.cloud.discoveryengine.v1alpha.Document] to update
    /// does not exist and
    /// [allow_missing][google.cloud.discoveryengine.v1alpha.UpdateDocumentRequest.allow_missing]
    /// is not set, a `NOT_FOUND` error is returned.
    #[prost(message, optional, tag = "1")]
    pub document: ::core::option::Option<Document>,
    /// If set to `true` and the
    /// [Document][google.cloud.discoveryengine.v1alpha.Document] is not found, a
    /// new [Document][google.cloud.discoveryengine.v1alpha.Document] is be
    /// created.
    #[prost(bool, tag = "2")]
    pub allow_missing: bool,
    /// Indicates which fields in the provided imported 'document' to update. If
    /// not set, by default updates all fields.
    #[prost(message, optional, tag = "3")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request message for
/// [DocumentService.DeleteDocument][google.cloud.discoveryengine.v1alpha.DocumentService.DeleteDocument]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteDocumentRequest {
    /// Required. Full resource name of
    /// [Document][google.cloud.discoveryengine.v1alpha.Document], such as
    /// `projects/{project}/locations/{location}/collections/{collection}/dataStores/{data_store}/branches/{branch}/documents/{document}`.
    ///
    /// If the caller does not have permission to delete the
    /// [Document][google.cloud.discoveryengine.v1alpha.Document], regardless of
    /// whether or not it exists, a `PERMISSION_DENIED` error is returned.
    ///
    /// If the [Document][google.cloud.discoveryengine.v1alpha.Document] to delete
    /// does not exist, a `NOT_FOUND` error is returned.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for
/// [DocumentService.GetDocument][google.cloud.discoveryengine.v1alpha.DocumentService.GetDocument]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetProcessedDocumentRequest {
    /// Required. Full resource name of
    /// [Document][google.cloud.discoveryengine.v1alpha.Document], such as
    /// `projects/{project}/locations/{location}/collections/{collection}/dataStores/{data_store}/branches/{branch}/documents/{document}`.
    ///
    /// If the caller does not have permission to access the
    /// [Document][google.cloud.discoveryengine.v1alpha.Document], regardless of
    /// whether or not it exists, a `PERMISSION_DENIED` error is returned.
    ///
    /// If the requested [Document][google.cloud.discoveryengine.v1alpha.Document]
    /// does not exist, a `NOT_FOUND` error is returned.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. What type of processing to return.
    #[prost(
        enumeration = "get_processed_document_request::ProcessedDocumentType",
        tag = "2"
    )]
    pub processed_document_type: i32,
    /// What format output should be.  If unspecified, defaults to JSON.
    #[prost(
        enumeration = "get_processed_document_request::ProcessedDocumentFormat",
        tag = "3"
    )]
    pub processed_document_format: i32,
}
/// Nested message and enum types in `GetProcessedDocumentRequest`.
pub mod get_processed_document_request {
    /// The type of processing to return in the response.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ProcessedDocumentType {
        /// Default value.
        Unspecified = 0,
        /// Available for all data store parsing configs.
        ParsedDocument = 1,
        /// Only available if ChunkingConfig is enabled on the data store.
        ChunkedDocument = 2,
        /// Returns the converted Image bytes (as JPEG or PNG) if available.
        PngConvertedDocument = 3,
    }
    impl ProcessedDocumentType {
        /// 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 {
                ProcessedDocumentType::Unspecified => {
                    "PROCESSED_DOCUMENT_TYPE_UNSPECIFIED"
                }
                ProcessedDocumentType::ParsedDocument => "PARSED_DOCUMENT",
                ProcessedDocumentType::ChunkedDocument => "CHUNKED_DOCUMENT",
                ProcessedDocumentType::PngConvertedDocument => "PNG_CONVERTED_DOCUMENT",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "PROCESSED_DOCUMENT_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "PARSED_DOCUMENT" => Some(Self::ParsedDocument),
                "CHUNKED_DOCUMENT" => Some(Self::ChunkedDocument),
                "PNG_CONVERTED_DOCUMENT" => Some(Self::PngConvertedDocument),
                _ => None,
            }
        }
    }
    /// The format of the returned processed document. If unspecified, defaults to
    /// JSON.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ProcessedDocumentFormat {
        /// Default value.
        Unspecified = 0,
        /// Output format is a JSON string representation of processed document.
        Json = 1,
    }
    impl ProcessedDocumentFormat {
        /// 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 {
                ProcessedDocumentFormat::Unspecified => {
                    "PROCESSED_DOCUMENT_FORMAT_UNSPECIFIED"
                }
                ProcessedDocumentFormat::Json => "JSON",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "PROCESSED_DOCUMENT_FORMAT_UNSPECIFIED" => Some(Self::Unspecified),
                "JSON" => Some(Self::Json),
                _ => None,
            }
        }
    }
}
/// Request message for
/// [DocumentService.BatchGetDocumentsMetadata][google.cloud.discoveryengine.v1alpha.DocumentService.BatchGetDocumentsMetadata]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchGetDocumentsMetadataRequest {
    /// Required. The parent branch resource name, such as
    /// `projects/{project}/locations/{location}/collections/{collection}/dataStores/{data_store}/branches/{branch}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. Matcher for the
    /// [Document][google.cloud.discoveryengine.v1alpha.Document]s.
    #[prost(message, optional, tag = "2")]
    pub matcher: ::core::option::Option<batch_get_documents_metadata_request::Matcher>,
}
/// Nested message and enum types in `BatchGetDocumentsMetadataRequest`.
pub mod batch_get_documents_metadata_request {
    /// Matcher for the [Document][google.cloud.discoveryengine.v1alpha.Document]s
    /// by exact uris.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct UrisMatcher {
        /// The exact URIs to match by.
        #[prost(string, repeated, tag = "1")]
        pub uris: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    }
    /// Matcher for the [Document][google.cloud.discoveryengine.v1alpha.Document]s.
    /// Currently supports matching by exact URIs.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Matcher {
        /// Matcher for the
        /// [Document][google.cloud.discoveryengine.v1alpha.Document]s.
        #[prost(oneof = "matcher::Matcher", tags = "1")]
        pub matcher: ::core::option::Option<matcher::Matcher>,
    }
    /// Nested message and enum types in `Matcher`.
    pub mod matcher {
        /// Matcher for the
        /// [Document][google.cloud.discoveryengine.v1alpha.Document]s.
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum Matcher {
            /// Matcher by exact URIs.
            #[prost(message, tag = "1")]
            UrisMatcher(super::UrisMatcher),
        }
    }
}
/// Response message for
/// [DocumentService.BatchGetDocumentsMetadata][google.cloud.discoveryengine.v1alpha.DocumentService.BatchGetDocumentsMetadata]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchGetDocumentsMetadataResponse {
    /// The metadata of the
    /// [Document][google.cloud.discoveryengine.v1alpha.Document]s.
    #[prost(message, repeated, tag = "1")]
    pub documents_metadata: ::prost::alloc::vec::Vec<
        batch_get_documents_metadata_response::DocumentMetadata,
    >,
}
/// Nested message and enum types in `BatchGetDocumentsMetadataResponse`.
pub mod batch_get_documents_metadata_response {
    /// The metadata of a
    /// [Document][google.cloud.discoveryengine.v1alpha.Document].
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct DocumentMetadata {
        /// The value of the matcher that was used to match the
        /// [Document][google.cloud.discoveryengine.v1alpha.Document].
        #[prost(message, optional, tag = "2")]
        pub matcher_value: ::core::option::Option<document_metadata::MatcherValue>,
        /// The state of the document.
        #[prost(enumeration = "State", tag = "3")]
        pub state: i32,
        /// The timestamp of the last time the
        /// [Document][google.cloud.discoveryengine.v1alpha.Document] was last
        /// indexed.
        #[prost(message, optional, tag = "4")]
        pub last_refreshed_time: ::core::option::Option<::prost_types::Timestamp>,
    }
    /// Nested message and enum types in `DocumentMetadata`.
    pub mod document_metadata {
        /// The value of the matcher that was used to match the
        /// [Document][google.cloud.discoveryengine.v1alpha.Document].
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct MatcherValue {
            /// The value of the matcher that was used to match the
            /// [Document][google.cloud.discoveryengine.v1alpha.Document].
            #[prost(oneof = "matcher_value::MatcherValue", tags = "1")]
            pub matcher_value: ::core::option::Option<matcher_value::MatcherValue>,
        }
        /// Nested message and enum types in `MatcherValue`.
        pub mod matcher_value {
            /// The value of the matcher that was used to match the
            /// [Document][google.cloud.discoveryengine.v1alpha.Document].
            #[derive(Clone, PartialEq, ::prost::Oneof)]
            pub enum MatcherValue {
                /// If match by URI, the URI of the
                /// [Document][google.cloud.discoveryengine.v1alpha.Document].
                #[prost(string, tag = "1")]
                Uri(::prost::alloc::string::String),
            }
        }
    }
    /// The state of the
    /// [Document][google.cloud.discoveryengine.v1alpha.Document].
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        /// Should never be set.
        Unspecified = 0,
        /// The [Document][google.cloud.discoveryengine.v1alpha.Document] is indexed.
        Indexed = 1,
        /// The [Document][google.cloud.discoveryengine.v1alpha.Document] is not
        /// indexed because its URI is not in the
        /// [TargetSite][google.cloud.discoveryengine.v1alpha.TargetSite].
        NotInTargetSite = 2,
        /// The [Document][google.cloud.discoveryengine.v1alpha.Document] is not
        /// indexed.
        NotInIndex = 3,
    }
    impl State {
        /// 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 {
                State::Unspecified => "STATE_UNSPECIFIED",
                State::Indexed => "INDEXED",
                State::NotInTargetSite => "NOT_IN_TARGET_SITE",
                State::NotInIndex => "NOT_IN_INDEX",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATE_UNSPECIFIED" => Some(Self::Unspecified),
                "INDEXED" => Some(Self::Indexed),
                "NOT_IN_TARGET_SITE" => Some(Self::NotInTargetSite),
                "NOT_IN_INDEX" => Some(Self::NotInIndex),
                _ => None,
            }
        }
    }
}
/// Generated client implementations.
pub mod document_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for ingesting
    /// [Document][google.cloud.discoveryengine.v1alpha.Document] information of the
    /// customer's website.
    #[derive(Debug, Clone)]
    pub struct DocumentServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl<T> DocumentServiceClient<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,
        ) -> DocumentServiceClient<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,
        {
            DocumentServiceClient::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
        }
        /// Gets a [Document][google.cloud.discoveryengine.v1alpha.Document].
        pub async fn get_document(
            &mut self,
            request: impl tonic::IntoRequest<super::GetDocumentRequest>,
        ) -> std::result::Result<tonic::Response<super::Document>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.DocumentService/GetDocument",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.DocumentService",
                        "GetDocument",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets a list of [Document][google.cloud.discoveryengine.v1alpha.Document]s.
        pub async fn list_documents(
            &mut self,
            request: impl tonic::IntoRequest<super::ListDocumentsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListDocumentsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.DocumentService/ListDocuments",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.DocumentService",
                        "ListDocuments",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a [Document][google.cloud.discoveryengine.v1alpha.Document].
        pub async fn create_document(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateDocumentRequest>,
        ) -> std::result::Result<tonic::Response<super::Document>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.DocumentService/CreateDocument",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.DocumentService",
                        "CreateDocument",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates a [Document][google.cloud.discoveryengine.v1alpha.Document].
        pub async fn update_document(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateDocumentRequest>,
        ) -> std::result::Result<tonic::Response<super::Document>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.DocumentService/UpdateDocument",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.DocumentService",
                        "UpdateDocument",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes a [Document][google.cloud.discoveryengine.v1alpha.Document].
        pub async fn delete_document(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteDocumentRequest>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.DocumentService/DeleteDocument",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.DocumentService",
                        "DeleteDocument",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Bulk import of multiple
        /// [Document][google.cloud.discoveryengine.v1alpha.Document]s. Request
        /// processing may be synchronous. Non-existing items are created.
        ///
        /// Note: It is possible for a subset of the
        /// [Document][google.cloud.discoveryengine.v1alpha.Document]s to be
        /// successfully updated.
        pub async fn import_documents(
            &mut self,
            request: impl tonic::IntoRequest<super::ImportDocumentsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.DocumentService/ImportDocuments",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.DocumentService",
                        "ImportDocuments",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Permanently deletes all selected
        /// [Document][google.cloud.discoveryengine.v1alpha.Document]s in a branch.
        ///
        /// This process is asynchronous. Depending on the number of
        /// [Document][google.cloud.discoveryengine.v1alpha.Document]s to be deleted,
        /// this operation can take hours to complete. Before the delete operation
        /// completes, some [Document][google.cloud.discoveryengine.v1alpha.Document]s
        /// might still be returned by
        /// [DocumentService.GetDocument][google.cloud.discoveryengine.v1alpha.DocumentService.GetDocument]
        /// or
        /// [DocumentService.ListDocuments][google.cloud.discoveryengine.v1alpha.DocumentService.ListDocuments].
        ///
        /// To get a list of the
        /// [Document][google.cloud.discoveryengine.v1alpha.Document]s to be deleted,
        /// set
        /// [PurgeDocumentsRequest.force][google.cloud.discoveryengine.v1alpha.PurgeDocumentsRequest.force]
        /// to false.
        pub async fn purge_documents(
            &mut self,
            request: impl tonic::IntoRequest<super::PurgeDocumentsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.DocumentService/PurgeDocuments",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.DocumentService",
                        "PurgeDocuments",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets the parsed layout information for a
        /// [Document][google.cloud.discoveryengine.v1alpha.Document].
        pub async fn get_processed_document(
            &mut self,
            request: impl tonic::IntoRequest<super::GetProcessedDocumentRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ProcessedDocument>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.DocumentService/GetProcessedDocument",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.DocumentService",
                        "GetProcessedDocument",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets index freshness metadata for
        /// [Document][google.cloud.discoveryengine.v1alpha.Document]s. Supported for
        /// website search only.
        pub async fn batch_get_documents_metadata(
            &mut self,
            request: impl tonic::IntoRequest<super::BatchGetDocumentsMetadataRequest>,
        ) -> std::result::Result<
            tonic::Response<super::BatchGetDocumentsMetadataResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.DocumentService/BatchGetDocumentsMetadata",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.DocumentService",
                        "BatchGetDocumentsMetadata",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Request message for
/// [CompletionService.CompleteQuery][google.cloud.discoveryengine.v1alpha.CompletionService.CompleteQuery]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CompleteQueryRequest {
    /// Required. The parent data store resource name for which the completion is
    /// performed, such as
    /// `projects/*/locations/global/collections/default_collection/dataStores/default_data_store`.
    #[prost(string, tag = "1")]
    pub data_store: ::prost::alloc::string::String,
    /// Required. The typeahead input used to fetch suggestions. Maximum length is
    /// 128 characters.
    #[prost(string, tag = "2")]
    pub query: ::prost::alloc::string::String,
    /// Specifies the autocomplete data model. This overrides any model specified
    /// in the Configuration > Autocomplete section of the Cloud console. Currently
    /// supported values:
    ///
    /// * `document` - Using suggestions generated from user-imported documents.
    /// * `search-history` - Using suggestions generated from the past history of
    /// [SearchService.Search][google.cloud.discoveryengine.v1alpha.SearchService.Search]
    /// API calls. Do not use it when there is no traffic for Search API.
    /// * `user-event` - Using suggestions generated from user-imported search
    /// events.
    /// * `document-completable` - Using suggestions taken directly from
    /// user-imported document fields marked as completable.
    ///
    /// Default values:
    ///
    /// * `document` is the default model for regular dataStores.
    /// * `search-history` is the default model for site search dataStores.
    #[prost(string, tag = "3")]
    pub query_model: ::prost::alloc::string::String,
    /// A unique identifier for tracking visitors. For example, this could be
    /// implemented with an HTTP cookie, which should be able to uniquely identify
    /// a visitor on a single device. This unique identifier should not change if
    /// the visitor logs in or out of the website.
    ///
    /// This field should NOT have a fixed value such as `unknown_visitor`.
    ///
    /// This should be the same identifier as
    /// [UserEvent.user_pseudo_id][google.cloud.discoveryengine.v1alpha.UserEvent.user_pseudo_id]
    /// and
    /// [SearchRequest.user_pseudo_id][google.cloud.discoveryengine.v1alpha.SearchRequest.user_pseudo_id].
    ///
    /// The field must be a UTF-8 encoded string with a length limit of 128
    /// characters. Otherwise, an `INVALID_ARGUMENT` error is returned.
    #[prost(string, tag = "4")]
    pub user_pseudo_id: ::prost::alloc::string::String,
    /// Indicates if tail suggestions should be returned if there are no
    /// suggestions that match the full query. Even if set to true, if there are
    /// suggestions that match the full query, those are returned and no
    /// tail suggestions are returned.
    #[prost(bool, tag = "5")]
    pub include_tail_suggestions: bool,
}
/// Response message for
/// [CompletionService.CompleteQuery][google.cloud.discoveryengine.v1alpha.CompletionService.CompleteQuery]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CompleteQueryResponse {
    /// Results of the matched query suggestions. The result list is ordered and
    /// the first result is a top suggestion.
    #[prost(message, repeated, tag = "1")]
    pub query_suggestions: ::prost::alloc::vec::Vec<
        complete_query_response::QuerySuggestion,
    >,
    /// True if the returned suggestions are all tail suggestions.
    ///
    /// For tail matching to be triggered, include_tail_suggestions in the request
    /// must be true and there must be no suggestions that match the full query.
    #[prost(bool, tag = "2")]
    pub tail_match_triggered: bool,
}
/// Nested message and enum types in `CompleteQueryResponse`.
pub mod complete_query_response {
    /// Suggestions as search queries.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct QuerySuggestion {
        /// The suggestion for the query.
        #[prost(string, tag = "1")]
        pub suggestion: ::prost::alloc::string::String,
        /// The unique document field paths that serve as the source of this
        /// suggestion if it was generated from completable fields.
        ///
        /// This field is only populated for the document-completable model.
        #[prost(string, repeated, tag = "2")]
        pub completable_field_paths: ::prost::alloc::vec::Vec<
            ::prost::alloc::string::String,
        >,
    }
}
/// Generated client implementations.
pub mod completion_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for Auto-Completion.
    #[derive(Debug, Clone)]
    pub struct CompletionServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl<T> CompletionServiceClient<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,
        ) -> CompletionServiceClient<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,
        {
            CompletionServiceClient::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
        }
        /// Completes the specified user input with keyword suggestions.
        pub async fn complete_query(
            &mut self,
            request: impl tonic::IntoRequest<super::CompleteQueryRequest>,
        ) -> std::result::Result<
            tonic::Response<super::CompleteQueryResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.CompletionService/CompleteQuery",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.CompletionService",
                        "CompleteQuery",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Imports all
        /// [SuggestionDenyListEntry][google.cloud.discoveryengine.v1alpha.SuggestionDenyListEntry]
        /// for a DataStore.
        pub async fn import_suggestion_deny_list_entries(
            &mut self,
            request: impl tonic::IntoRequest<
                super::ImportSuggestionDenyListEntriesRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.CompletionService/ImportSuggestionDenyListEntries",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.CompletionService",
                        "ImportSuggestionDenyListEntries",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Permanently deletes all
        /// [SuggestionDenyListEntry][google.cloud.discoveryengine.v1alpha.SuggestionDenyListEntry]
        /// for a DataStore.
        pub async fn purge_suggestion_deny_list_entries(
            &mut self,
            request: impl tonic::IntoRequest<
                super::PurgeSuggestionDenyListEntriesRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.CompletionService/PurgeSuggestionDenyListEntries",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.CompletionService",
                        "PurgeSuggestionDenyListEntries",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Imports
        /// [CompletionSuggestion][google.cloud.discoveryengine.v1alpha.CompletionSuggestion]s
        /// for a DataStore.
        pub async fn import_completion_suggestions(
            &mut self,
            request: impl tonic::IntoRequest<super::ImportCompletionSuggestionsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.CompletionService/ImportCompletionSuggestions",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.CompletionService",
                        "ImportCompletionSuggestions",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Permanently deletes all
        /// [CompletionSuggestion][google.cloud.discoveryengine.v1alpha.CompletionSuggestion]s
        /// for a DataStore.
        pub async fn purge_completion_suggestions(
            &mut self,
            request: impl tonic::IntoRequest<super::PurgeCompletionSuggestionsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.CompletionService/PurgeCompletionSuggestions",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.CompletionService",
                        "PurgeCompletionSuggestions",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Request message for
/// [ChunkService.GetChunk][google.cloud.discoveryengine.v1alpha.ChunkService.GetChunk]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetChunkRequest {
    /// Required. Full resource name of
    /// [Chunk][google.cloud.discoveryengine.v1alpha.Chunk], such as
    /// `projects/{project}/locations/{location}/collections/{collection}/dataStores/{data_store}/branches/{branch}/documents/{document}/chunks/{chunk}`.
    ///
    /// If the caller does not have permission to access the
    /// [Chunk][google.cloud.discoveryengine.v1alpha.Chunk], regardless of whether
    /// or not it exists, a `PERMISSION_DENIED` error is returned.
    ///
    /// If the requested [Chunk][google.cloud.discoveryengine.v1alpha.Chunk] does
    /// not exist, a `NOT_FOUND` error is returned.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for
/// [ChunkService.ListChunks][google.cloud.discoveryengine.v1alpha.ChunkService.ListChunks]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListChunksRequest {
    /// Required. The parent document resource name, such as
    /// `projects/{project}/locations/{location}/collections/{collection}/dataStores/{data_store}/branches/{branch}/documents/{document}`.
    ///
    /// If the caller does not have permission to list
    /// [Chunk][google.cloud.discoveryengine.v1alpha.Chunk]s under this document,
    /// regardless of whether or not this document exists, a `PERMISSION_DENIED`
    /// error is returned.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Maximum number of [Chunk][google.cloud.discoveryengine.v1alpha.Chunk]s to
    /// return. If unspecified, defaults to 100. The maximum allowed value is 1000.
    /// Values above 1000 will be coerced to 1000.
    ///
    /// If this field is negative, an `INVALID_ARGUMENT` error is returned.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// A page token
    /// [ListChunksResponse.next_page_token][google.cloud.discoveryengine.v1alpha.ListChunksResponse.next_page_token],
    /// received from a previous
    /// [ChunkService.ListChunks][google.cloud.discoveryengine.v1alpha.ChunkService.ListChunks]
    /// call. Provide this to retrieve the subsequent page.
    ///
    /// When paginating, all other parameters provided to
    /// [ChunkService.ListChunks][google.cloud.discoveryengine.v1alpha.ChunkService.ListChunks]
    /// must match the call that provided the page token. Otherwise, an
    /// `INVALID_ARGUMENT` error is returned.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// Response message for
/// [ChunkService.ListChunks][google.cloud.discoveryengine.v1alpha.ChunkService.ListChunks]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListChunksResponse {
    /// The [Chunk][google.cloud.discoveryengine.v1alpha.Chunk]s.
    #[prost(message, repeated, tag = "1")]
    pub chunks: ::prost::alloc::vec::Vec<Chunk>,
    /// A token that can be sent as
    /// [ListChunksRequest.page_token][google.cloud.discoveryengine.v1alpha.ListChunksRequest.page_token]
    /// to retrieve the next page. If this field is omitted, there are no
    /// subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod chunk_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for displaying processed
    /// [Chunk][google.cloud.discoveryengine.v1alpha.Chunk] information of the
    /// customer's unstructured data.
    #[derive(Debug, Clone)]
    pub struct ChunkServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl<T> ChunkServiceClient<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,
        ) -> ChunkServiceClient<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,
        {
            ChunkServiceClient::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
        }
        /// Gets a [Document][google.cloud.discoveryengine.v1alpha.Document].
        pub async fn get_chunk(
            &mut self,
            request: impl tonic::IntoRequest<super::GetChunkRequest>,
        ) -> std::result::Result<tonic::Response<super::Chunk>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.ChunkService/GetChunk",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.ChunkService",
                        "GetChunk",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets a list of [Chunk][google.cloud.discoveryengine.v1alpha.Chunk]s.
        pub async fn list_chunks(
            &mut self,
            request: impl tonic::IntoRequest<super::ListChunksRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListChunksResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.ChunkService/ListChunks",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.ChunkService",
                        "ListChunks",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Metadata that describes a custom tuned model.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CustomTuningModel {
    /// Required. The fully qualified resource name of the model.
    ///
    /// Format:
    /// `projects/{project_number}/locations/{location}/collections/{collection}/dataStores/{data_store}/customTuningModels/{custom_tuning_model}`
    /// model must be an alpha-numerical string with limit of 40 characters.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The display name of the model.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// The version of the model.
    #[prost(int64, tag = "3")]
    pub model_version: i64,
    /// The state that the model is in (e.g.`TRAINING` or `TRAINING_FAILED`).
    #[prost(enumeration = "custom_tuning_model::ModelState", tag = "4")]
    pub model_state: i32,
    /// Timestamp the Model was created at.
    #[deprecated]
    #[prost(message, optional, tag = "5")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Timestamp the model training was initiated.
    #[prost(message, optional, tag = "6")]
    pub training_start_time: ::core::option::Option<::prost_types::Timestamp>,
    /// The metrics of the trained model.
    #[prost(btree_map = "string, double", tag = "7")]
    pub metrics: ::prost::alloc::collections::BTreeMap<
        ::prost::alloc::string::String,
        f64,
    >,
}
/// Nested message and enum types in `CustomTuningModel`.
pub mod custom_tuning_model {
    /// The state of the model.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ModelState {
        /// Default value.
        Unspecified = 0,
        /// The model is in a paused training state.
        TrainingPaused = 1,
        /// The model is currently training.
        Training = 2,
        /// The model has successfully completed training.
        TrainingComplete = 3,
        /// The model is ready for serving.
        ReadyForServing = 4,
        /// The model training failed.
        TrainingFailed = 5,
        /// The model training finished successfully but metrics did not improve.
        NoImprovement = 6,
        /// Input data validation failed. Model training didn't start.
        InputValidationFailed = 7,
    }
    impl ModelState {
        /// 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 {
                ModelState::Unspecified => "MODEL_STATE_UNSPECIFIED",
                ModelState::TrainingPaused => "TRAINING_PAUSED",
                ModelState::Training => "TRAINING",
                ModelState::TrainingComplete => "TRAINING_COMPLETE",
                ModelState::ReadyForServing => "READY_FOR_SERVING",
                ModelState::TrainingFailed => "TRAINING_FAILED",
                ModelState::NoImprovement => "NO_IMPROVEMENT",
                ModelState::InputValidationFailed => "INPUT_VALIDATION_FAILED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "MODEL_STATE_UNSPECIFIED" => Some(Self::Unspecified),
                "TRAINING_PAUSED" => Some(Self::TrainingPaused),
                "TRAINING" => Some(Self::Training),
                "TRAINING_COMPLETE" => Some(Self::TrainingComplete),
                "READY_FOR_SERVING" => Some(Self::ReadyForServing),
                "TRAINING_FAILED" => Some(Self::TrainingFailed),
                "NO_IMPROVEMENT" => Some(Self::NoImprovement),
                "INPUT_VALIDATION_FAILED" => Some(Self::InputValidationFailed),
                _ => None,
            }
        }
    }
}
/// Request message for
/// [SearchTuningService.ListCustomModels][google.cloud.discoveryengine.v1alpha.SearchTuningService.ListCustomModels]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListCustomModelsRequest {
    /// Required. The resource name of the parent Data Store, such as
    /// `projects/*/locations/global/collections/default_collection/dataStores/default_data_store`.
    /// This field is used to identify the data store where to fetch the models
    /// from.
    #[prost(string, tag = "1")]
    pub data_store: ::prost::alloc::string::String,
}
/// Response message for
/// [SearchTuningService.ListCustomModels][google.cloud.discoveryengine.v1alpha.SearchTuningService.ListCustomModels]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListCustomModelsResponse {
    /// List of custom tuning models.
    #[prost(message, repeated, tag = "1")]
    pub models: ::prost::alloc::vec::Vec<CustomTuningModel>,
}
/// Request message for
/// [SearchTuningService.TrainCustomModel][google.cloud.discoveryengine.v1alpha.SearchTuningService.TrainCustomModel]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TrainCustomModelRequest {
    /// Required. The resource name of the Data Store, such as
    /// `projects/*/locations/global/collections/default_collection/dataStores/default_data_store`.
    /// This field is used to identify the data store where to train the models.
    #[prost(string, tag = "1")]
    pub data_store: ::prost::alloc::string::String,
    /// Model to be trained. Supported values are:
    ///
    ///   * **search-tuning**: Fine tuning the search system based on data provided.
    #[prost(string, tag = "3")]
    pub model_type: ::prost::alloc::string::String,
    /// The desired location of errors incurred during the data ingestion and
    /// training.
    #[prost(message, optional, tag = "4")]
    pub error_config: ::core::option::Option<ImportErrorConfig>,
    /// If not provided, a UUID will be generated.
    #[prost(string, tag = "5")]
    pub model_id: ::prost::alloc::string::String,
    /// Model training input.
    #[prost(oneof = "train_custom_model_request::TrainingInput", tags = "2")]
    pub training_input: ::core::option::Option<
        train_custom_model_request::TrainingInput,
    >,
}
/// Nested message and enum types in `TrainCustomModelRequest`.
pub mod train_custom_model_request {
    /// Cloud Storage training data input.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct GcsTrainingInput {
        /// The Cloud Storage corpus data which could be associated in train data.
        /// The data path format is `gs://<bucket_to_data>/<jsonl_file_name>`.
        /// A newline delimited jsonl/ndjson file.
        ///
        /// For search-tuning model, each line should have the _id, title
        /// and text. Example:
        /// `{"_id": "doc1", title: "relevant doc", "text": "relevant text"}`
        #[prost(string, tag = "1")]
        pub corpus_data_path: ::prost::alloc::string::String,
        /// The gcs query data which could be associated in train data.
        /// The data path format is `gs://<bucket_to_data>/<jsonl_file_name>`.
        /// A newline delimited jsonl/ndjson file.
        ///
        /// For search-tuning model, each line should have the _id
        /// and text. Example: {"_id": "query1",  "text": "example query"}
        #[prost(string, tag = "2")]
        pub query_data_path: ::prost::alloc::string::String,
        /// Cloud Storage training data path whose format should be
        /// `gs://<bucket_to_data>/<tsv_file_name>`. The file should be in tsv
        /// format. Each line should have the doc_id and query_id and score (number).
        ///
        /// For search-tuning model, it should have the query-id corpus-id
        /// score as tsv file header. The score should be a number in `[0, inf+)`.
        /// The larger the number is, the more relevant the pair is. Example:
        ///
        /// * `query-id\tcorpus-id\tscore`
        /// * `query1\tdoc1\t1`
        #[prost(string, tag = "3")]
        pub train_data_path: ::prost::alloc::string::String,
        /// Cloud Storage test data. Same format as train_data_path. If not provided,
        /// a random 80/20 train/test split will be performed on train_data_path.
        #[prost(string, tag = "4")]
        pub test_data_path: ::prost::alloc::string::String,
    }
    /// Model training input.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum TrainingInput {
        /// Cloud Storage training input.
        #[prost(message, tag = "2")]
        GcsTrainingInput(GcsTrainingInput),
    }
}
/// Response of the
/// [TrainCustomModelRequest][google.cloud.discoveryengine.v1alpha.TrainCustomModelRequest].
/// This message is returned by the google.longrunning.Operations.response field.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TrainCustomModelResponse {
    /// A sample of errors encountered while processing the data.
    #[prost(message, repeated, tag = "1")]
    pub error_samples: ::prost::alloc::vec::Vec<super::super::super::rpc::Status>,
    /// Echoes the destination for the complete errors in the request if set.
    #[prost(message, optional, tag = "2")]
    pub error_config: ::core::option::Option<ImportErrorConfig>,
    /// The trained model status. Possible values are:
    ///
    ///   * **bad-data**: The training data quality is bad.
    ///   * **no-improvement**: Tuning didn't improve performance. Won't deploy.
    ///   * **in-progress**: Model training job creation is in progress.
    ///   * **training**: Model is actively training.
    ///   * **evaluating**: The model is evaluating trained metrics.
    ///   * **indexing**: The model trained metrics are indexing.
    ///   * **ready**: The model is ready for serving.
    #[prost(string, tag = "3")]
    pub model_status: ::prost::alloc::string::String,
    /// The metrics of the trained model.
    #[prost(btree_map = "string, double", tag = "4")]
    pub metrics: ::prost::alloc::collections::BTreeMap<
        ::prost::alloc::string::String,
        f64,
    >,
    /// Fully qualified name of the CustomTuningModel.
    #[prost(string, tag = "5")]
    pub model_name: ::prost::alloc::string::String,
}
/// Metadata related to the progress of the TrainCustomModel operation. This is
/// returned by the google.longrunning.Operation.metadata field.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct TrainCustomModelMetadata {
    /// Operation create time.
    #[prost(message, optional, tag = "1")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Operation last update time. If the operation is done, this is also the
    /// finish time.
    #[prost(message, optional, tag = "2")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Generated client implementations.
pub mod search_tuning_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for search tuning.
    #[derive(Debug, Clone)]
    pub struct SearchTuningServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl<T> SearchTuningServiceClient<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,
        ) -> SearchTuningServiceClient<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,
        {
            SearchTuningServiceClient::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
        }
        /// Trains a custom model.
        pub async fn train_custom_model(
            &mut self,
            request: impl tonic::IntoRequest<super::TrainCustomModelRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.SearchTuningService/TrainCustomModel",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.SearchTuningService",
                        "TrainCustomModel",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets a list of all the custom models.
        pub async fn list_custom_models(
            &mut self,
            request: impl tonic::IntoRequest<super::ListCustomModelsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListCustomModelsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.SearchTuningService/ListCustomModels",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.SearchTuningService",
                        "ListCustomModels",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Configures metadata that is used to generate serving time results (e.g.
/// search results or recommendation predictions).
/// The ServingConfig is passed in the search and predict request and generates
/// results.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ServingConfig {
    /// Immutable. Fully qualified name
    /// `projects/{project}/locations/{location}/collections/{collection_id}/engines/{engine_id}/servingConfigs/{serving_config_id}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. The human readable serving config display name. Used in Discovery
    /// UI.
    ///
    /// This field must be a UTF-8 encoded string with a length limit of 128
    /// characters. Otherwise, an INVALID_ARGUMENT error is returned.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// Required. Immutable. Specifies the solution type that a serving config can
    /// be associated with.
    #[prost(enumeration = "SolutionType", tag = "3")]
    pub solution_type: i32,
    /// The id of the model to use at serving time.
    /// Currently only RecommendationModels are supported.
    /// Can be changed but only to a compatible model (e.g.
    /// others-you-may-like CTR to others-you-may-like CVR).
    ///
    /// Required when
    /// [SolutionType][google.cloud.discoveryengine.v1alpha.SolutionType] is
    /// [SOLUTION_TYPE_RECOMMENDATION][google.cloud.discoveryengine.v1alpha.SolutionType.SOLUTION_TYPE_RECOMMENDATION].
    #[prost(string, tag = "4")]
    pub model_id: ::prost::alloc::string::String,
    /// How much diversity to use in recommendation model results e.g.
    /// `medium-diversity` or `high-diversity`. Currently supported values:
    ///
    /// * `no-diversity`
    /// * `low-diversity`
    /// * `medium-diversity`
    /// * `high-diversity`
    /// * `auto-diversity`
    ///
    /// If not specified, we choose default based on recommendation model
    /// type. Default value: `no-diversity`.
    ///
    /// Can only be set if
    /// [SolutionType][google.cloud.discoveryengine.v1alpha.SolutionType] is
    /// [SOLUTION_TYPE_RECOMMENDATION][google.cloud.discoveryengine.v1alpha.SolutionType.SOLUTION_TYPE_RECOMMENDATION].
    #[prost(string, tag = "5")]
    pub diversity_level: ::prost::alloc::string::String,
    /// Bring your own embedding config. The config is used for search semantic
    /// retrieval. The retrieval is based on the dot product of
    /// [SearchRequest.EmbeddingSpec.EmbeddingVector.vector][google.cloud.discoveryengine.v1alpha.SearchRequest.EmbeddingSpec.EmbeddingVector.vector]
    /// and the document embeddings that are provided by this EmbeddingConfig. If
    /// [SearchRequest.EmbeddingSpec.EmbeddingVector.vector][google.cloud.discoveryengine.v1alpha.SearchRequest.EmbeddingSpec.EmbeddingVector.vector]
    /// is provided, it overrides this
    /// [ServingConfig.embedding_config][google.cloud.discoveryengine.v1alpha.ServingConfig.embedding_config].
    #[prost(message, optional, tag = "20")]
    pub embedding_config: ::core::option::Option<EmbeddingConfig>,
    /// The ranking expression controls the customized ranking on retrieval
    /// documents. To leverage this, document embedding is required. The ranking
    /// expression setting in ServingConfig applies to all search requests served
    /// by the serving config. However, if
    /// [SearchRequest.ranking_expression][google.cloud.discoveryengine.v1alpha.SearchRequest.ranking_expression]
    /// is specified, it overrides the ServingConfig ranking expression.
    ///
    /// The ranking expression is a single function or multiple functions that are
    /// joined by "+".
    ///
    ///    * ranking_expression = function, { " + ", function };
    ///
    /// Supported functions:
    ///
    ///    * double * relevance_score
    ///    * double * dotProduct(embedding_field_path)
    ///
    /// Function variables:
    ///
    ///    * `relevance_score`: pre-defined keywords, used for measure relevance
    ///    between query and document.
    ///    * `embedding_field_path`: the document embedding field
    ///    used with query embedding vector.
    ///    * `dotProduct`: embedding function between embedding_field_path and query
    ///    embedding vector.
    ///
    ///   Example ranking expression:
    ///
    ///     If document has an embedding field doc_embedding, the ranking expression
    ///     could be `0.5 * relevance_score + 0.3 * dotProduct(doc_embedding)`.
    #[prost(string, tag = "21")]
    pub ranking_expression: ::prost::alloc::string::String,
    /// Guided search configs.
    #[prost(message, optional, tag = "22")]
    pub guided_search_spec: ::core::option::Option<GuidedSearchSpec>,
    /// Custom fine tuning configs.
    /// If
    /// [SearchRequest.custom_fine_tuning_spec][google.cloud.discoveryengine.v1alpha.SearchRequest.custom_fine_tuning_spec]
    /// is set, it has higher priority than the configs set here.
    #[prost(message, optional, tag = "24")]
    pub custom_fine_tuning_spec: ::core::option::Option<CustomFineTuningSpec>,
    /// Output only. ServingConfig created timestamp.
    #[prost(message, optional, tag = "8")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. ServingConfig updated timestamp.
    #[prost(message, optional, tag = "9")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Filter controls to use in serving path.
    /// All triggered filter controls will be applied.
    /// Filter controls must be in the same data store as the serving config.
    /// Maximum of 20 filter controls.
    #[prost(string, repeated, tag = "11")]
    pub filter_control_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Boost controls to use in serving path.
    /// All triggered boost controls will be applied.
    /// Boost controls must be in the same data store as the serving config.
    /// Maximum of 20 boost controls.
    #[prost(string, repeated, tag = "12")]
    pub boost_control_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// IDs of the redirect controls. Only the first triggered redirect
    /// action is applied, even if multiple apply. Maximum number of
    /// specifications is 100.
    ///
    /// Can only be set if
    /// [SolutionType][google.cloud.discoveryengine.v1alpha.SolutionType] is
    /// [SOLUTION_TYPE_SEARCH][google.cloud.discoveryengine.v1alpha.SolutionType.SOLUTION_TYPE_SEARCH].
    #[prost(string, repeated, tag = "14")]
    pub redirect_control_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Condition synonyms specifications. If multiple synonyms conditions
    /// match, all matching synonyms controls in the list will execute.
    /// Maximum number of specifications is 100.
    ///
    /// Can only be set if
    /// [SolutionType][google.cloud.discoveryengine.v1alpha.SolutionType] is
    /// [SOLUTION_TYPE_SEARCH][google.cloud.discoveryengine.v1alpha.SolutionType.SOLUTION_TYPE_SEARCH].
    #[prost(string, repeated, tag = "15")]
    pub synonyms_control_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Condition oneway synonyms specifications. If multiple oneway synonyms
    /// conditions match, all matching oneway synonyms controls in the list
    /// will execute. Maximum number of specifications is 100.
    ///
    /// Can only be set if
    /// [SolutionType][google.cloud.discoveryengine.v1alpha.SolutionType] is
    /// [SOLUTION_TYPE_SEARCH][google.cloud.discoveryengine.v1alpha.SolutionType.SOLUTION_TYPE_SEARCH].
    #[prost(string, repeated, tag = "16")]
    pub oneway_synonyms_control_ids: ::prost::alloc::vec::Vec<
        ::prost::alloc::string::String,
    >,
    /// Condition do not associate specifications. If multiple do not
    /// associate conditions match, all matching do not associate controls in
    /// the list will execute.
    /// Order does not matter.
    /// Maximum number of specifications is 100.
    ///
    /// Can only be set if
    /// [SolutionType][google.cloud.discoveryengine.v1alpha.SolutionType] is
    /// [SOLUTION_TYPE_SEARCH][google.cloud.discoveryengine.v1alpha.SolutionType.SOLUTION_TYPE_SEARCH].
    #[prost(string, repeated, tag = "17")]
    pub dissociate_control_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Condition replacement specifications.
    /// Applied according to the order in the list.
    /// A previously replaced term can not be re-replaced.
    /// Maximum number of specifications is 100.
    ///
    /// Can only be set if
    /// [SolutionType][google.cloud.discoveryengine.v1alpha.SolutionType] is
    /// [SOLUTION_TYPE_SEARCH][google.cloud.discoveryengine.v1alpha.SolutionType.SOLUTION_TYPE_SEARCH].
    #[prost(string, repeated, tag = "18")]
    pub replacement_control_ids: ::prost::alloc::vec::Vec<
        ::prost::alloc::string::String,
    >,
    /// Condition ignore specifications. If multiple ignore
    /// conditions match, all matching ignore controls in the list will
    /// execute.
    /// Order does not matter.
    /// Maximum number of specifications is 100.
    #[prost(string, repeated, tag = "19")]
    pub ignore_control_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Industry vertical specific config.
    #[prost(oneof = "serving_config::VerticalConfig", tags = "7, 10")]
    pub vertical_config: ::core::option::Option<serving_config::VerticalConfig>,
}
/// Nested message and enum types in `ServingConfig`.
pub mod serving_config {
    /// Specifies the configurations needed for Media Discovery. Currently we
    /// support:
    ///
    /// * `demote_content_watched`: Threshold for watched content demotion.
    /// Customers can specify if using watched content demotion or use viewed
    /// detail page. Using the content watched demotion, customers need to specify
    /// the watched minutes or percentage exceeds the threshold, the content will
    /// be demoted in the recommendation result.
    /// * `promote_fresh_content`: cutoff days for fresh content promotion.
    /// Customers can specify if using content freshness promotion. If the content
    /// was published within the cutoff days, the content will be promoted in the
    /// recommendation result.
    /// Can only be set if
    /// [SolutionType][google.cloud.discoveryengine.v1alpha.SolutionType] is
    /// [SOLUTION_TYPE_RECOMMENDATION][google.cloud.discoveryengine.v1alpha.SolutionType.SOLUTION_TYPE_RECOMMENDATION].
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MediaConfig {
        /// Specifies the event type used for demoting recommendation result.
        /// Currently supported values:
        ///
        /// * `view-item`: Item viewed.
        /// * `media-play`: Start/resume watching a video, playing a song, etc.
        /// * `media-complete`: Finished or stopped midway through a video, song,
        /// etc.
        ///
        /// If unset, watch history demotion will not be applied. Content freshness
        /// demotion will still be applied.
        #[prost(string, tag = "1")]
        pub demotion_event_type: ::prost::alloc::string::String,
        /// Specifies the content freshness used for recommendation result.
        /// Contents will be demoted if contents were published for more than content
        /// freshness cutoff days.
        #[prost(int32, tag = "4")]
        pub content_freshness_cutoff_days: i32,
        /// Specify the threshold for demoting watched content, the threshold can be
        /// either percentage or minutes value.
        /// This must be set for `media-complete` event type.
        #[prost(oneof = "media_config::DemoteContentWatched", tags = "2, 5")]
        pub demote_content_watched: ::core::option::Option<
            media_config::DemoteContentWatched,
        >,
    }
    /// Nested message and enum types in `MediaConfig`.
    pub mod media_config {
        /// Specify the threshold for demoting watched content, the threshold can be
        /// either percentage or minutes value.
        /// This must be set for `media-complete` event type.
        #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
        pub enum DemoteContentWatched {
            /// Specifies the content watched percentage threshold for demotion.
            /// Threshold value must be between \[0, 1.0\] inclusive.
            #[prost(float, tag = "2")]
            ContentWatchedPercentageThreshold(f32),
            /// Specifies the content watched minutes threshold for demotion.
            #[prost(float, tag = "5")]
            ContentWatchedSecondsThreshold(f32),
        }
    }
    /// Specifies the configurations needed for Generic Discovery.Currently we
    /// support:
    ///
    /// * `content_search_spec`: configuration for generic content search.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct GenericConfig {
        /// Specifies the expected behavior of content search.
        /// Only valid for content-search enabled data store.
        #[prost(message, optional, tag = "1")]
        pub content_search_spec: ::core::option::Option<
            super::search_request::ContentSearchSpec,
        >,
    }
    /// Industry vertical specific config.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum VerticalConfig {
        /// The MediaConfig of the serving configuration.
        #[prost(message, tag = "7")]
        MediaConfig(MediaConfig),
        /// The GenericConfig of the serving configuration.
        #[prost(message, tag = "10")]
        GenericConfig(GenericConfig),
    }
}
/// Request for UpdateServingConfig method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateServingConfigRequest {
    /// Required. The ServingConfig to update.
    #[prost(message, optional, tag = "1")]
    pub serving_config: ::core::option::Option<ServingConfig>,
    /// Indicates which fields in the provided
    /// [ServingConfig][google.cloud.discoveryengine.v1alpha.ServingConfig] to
    /// update. The following are NOT supported:
    ///
    /// * [ServingConfig.name][google.cloud.discoveryengine.v1alpha.ServingConfig.name]
    ///
    /// If not set, all supported fields are updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request for GetServingConfig method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetServingConfigRequest {
    /// Required. The resource name of the ServingConfig to get. Format:
    /// `projects/{project_number}/locations/{location}/collections/{collection}/engines/{engine}/servingConfigs/{serving_config_id}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request for ListServingConfigs method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListServingConfigsRequest {
    /// Required. Full resource name of the parent resource. Format:
    /// `projects/{project_number}/locations/{location}/collections/{collection}/engines/{engine}`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. Maximum number of results to return. If unspecified, defaults
    /// to 100. If a value greater than 100 is provided, at most 100 results are
    /// returned.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. A page token, received from a previous `ListServingConfigs` call.
    /// Provide this to retrieve the subsequent page.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// Response for ListServingConfigs method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListServingConfigsResponse {
    /// All the ServingConfigs for a given dataStore.
    #[prost(message, repeated, tag = "1")]
    pub serving_configs: ::prost::alloc::vec::Vec<ServingConfig>,
    /// Pagination token, if not returned indicates the last page.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod serving_config_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for operations related to
    /// [ServingConfig][google.cloud.discoveryengine.v1alpha.ServingConfig].
    #[derive(Debug, Clone)]
    pub struct ServingConfigServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl<T> ServingConfigServiceClient<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,
        ) -> ServingConfigServiceClient<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,
        {
            ServingConfigServiceClient::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
        }
        /// Updates a ServingConfig.
        ///
        /// Returns a NOT_FOUND error if the ServingConfig does not exist.
        pub async fn update_serving_config(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateServingConfigRequest>,
        ) -> std::result::Result<tonic::Response<super::ServingConfig>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.ServingConfigService/UpdateServingConfig",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.ServingConfigService",
                        "UpdateServingConfig",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets a ServingConfig.
        ///
        /// Returns a NotFound error if the ServingConfig does not exist.
        pub async fn get_serving_config(
            &mut self,
            request: impl tonic::IntoRequest<super::GetServingConfigRequest>,
        ) -> std::result::Result<tonic::Response<super::ServingConfig>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.ServingConfigService/GetServingConfig",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.ServingConfigService",
                        "GetServingConfig",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists all ServingConfigs linked to this dataStore.
        pub async fn list_serving_configs(
            &mut self,
            request: impl tonic::IntoRequest<super::ListServingConfigsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListServingConfigsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.ServingConfigService/ListServingConfigs",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.ServingConfigService",
                        "ListServingConfigs",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// SiteSearchEngine captures DataStore level site search persisting
/// configurations. It is a singleton value per data store.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SiteSearchEngine {
    /// The fully qualified resource name of the site search engine.
    /// Format: `projects/*/locations/*/dataStores/*/siteSearchEngine`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// A target site for the SiteSearchEngine.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TargetSite {
    /// Output only. The fully qualified resource name of the target site.
    /// `projects/{project}/locations/{location}/collections/{collection}/dataStores/{data_store}/siteSearchEngine/targetSites/{target_site}`
    /// The `target_site_id` is system-generated.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. Input only. The user provided URI pattern from which the
    /// `generated_uri_pattern` is generated.
    #[prost(string, tag = "2")]
    pub provided_uri_pattern: ::prost::alloc::string::String,
    /// The type of the target site, e.g., whether the site is to be included or
    /// excluded.
    #[prost(enumeration = "target_site::Type", tag = "3")]
    pub r#type: i32,
    /// Input only. If set to false, a uri_pattern is generated to include all
    /// pages whose address contains the provided_uri_pattern. If set to true, an
    /// uri_pattern is generated to try to be an exact match of the
    /// provided_uri_pattern or just the specific page if the provided_uri_pattern
    /// is a specific one. provided_uri_pattern is always normalized to
    /// generate the URI pattern to be used by the search engine.
    #[prost(bool, tag = "6")]
    pub exact_match: bool,
    /// Output only. This is system-generated based on the provided_uri_pattern.
    #[prost(string, tag = "4")]
    pub generated_uri_pattern: ::prost::alloc::string::String,
    /// Output only. Root domain of the provided_uri_pattern.
    #[prost(string, tag = "10")]
    pub root_domain_uri: ::prost::alloc::string::String,
    /// Output only. Site ownership and validity verification status.
    #[prost(message, optional, tag = "7")]
    pub site_verification_info: ::core::option::Option<SiteVerificationInfo>,
    /// Output only. Indexing status.
    #[prost(enumeration = "target_site::IndexingStatus", tag = "8")]
    pub indexing_status: i32,
    /// Output only. The target site's last updated time.
    #[prost(message, optional, tag = "5")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Failure reason.
    #[prost(message, optional, tag = "9")]
    pub failure_reason: ::core::option::Option<target_site::FailureReason>,
}
/// Nested message and enum types in `TargetSite`.
pub mod target_site {
    /// Site search indexing failure reasons.
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct FailureReason {
        /// Failure reason.
        #[prost(oneof = "failure_reason::Failure", tags = "1")]
        pub failure: ::core::option::Option<failure_reason::Failure>,
    }
    /// Nested message and enum types in `FailureReason`.
    pub mod failure_reason {
        /// Failed due to insufficient quota.
        #[derive(Clone, Copy, PartialEq, ::prost::Message)]
        pub struct QuotaFailure {
            /// This number is an estimation on how much total quota this project needs
            /// to successfully complete indexing.
            #[prost(int64, tag = "1")]
            pub total_required_quota: i64,
        }
        /// Failure reason.
        #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
        pub enum Failure {
            /// Failed due to insufficient quota.
            #[prost(message, tag = "1")]
            QuotaFailure(QuotaFailure),
        }
    }
    /// Possible target site types.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Type {
        /// This value is unused. In this case, server behavior defaults to
        /// [Type.INCLUDE][google.cloud.discoveryengine.v1alpha.TargetSite.Type.INCLUDE].
        Unspecified = 0,
        /// Include the target site.
        Include = 1,
        /// Exclude the target site.
        Exclude = 2,
    }
    impl Type {
        /// 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 {
                Type::Unspecified => "TYPE_UNSPECIFIED",
                Type::Include => "INCLUDE",
                Type::Exclude => "EXCLUDE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "INCLUDE" => Some(Self::Include),
                "EXCLUDE" => Some(Self::Exclude),
                _ => None,
            }
        }
    }
    /// Target site indexing status enumeration.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum IndexingStatus {
        /// Defaults to SUCCEEDED.
        Unspecified = 0,
        /// The target site is in the update queue and will be picked up by indexing
        /// pipeline.
        Pending = 1,
        /// The target site fails to be indexed.
        Failed = 2,
        /// The target site has been indexed.
        Succeeded = 3,
        /// The previously indexed target site has been marked to be deleted. This is
        /// a transitioning state which will resulted in either:
        /// 1. target site deleted if unindexing is successful;
        /// 2. state reverts to SUCCEEDED if the unindexing fails.
        Deleting = 4,
    }
    impl IndexingStatus {
        /// 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 {
                IndexingStatus::Unspecified => "INDEXING_STATUS_UNSPECIFIED",
                IndexingStatus::Pending => "PENDING",
                IndexingStatus::Failed => "FAILED",
                IndexingStatus::Succeeded => "SUCCEEDED",
                IndexingStatus::Deleting => "DELETING",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "INDEXING_STATUS_UNSPECIFIED" => Some(Self::Unspecified),
                "PENDING" => Some(Self::Pending),
                "FAILED" => Some(Self::Failed),
                "SUCCEEDED" => Some(Self::Succeeded),
                "DELETING" => Some(Self::Deleting),
                _ => None,
            }
        }
    }
}
/// Verification information for target sites in advanced site search.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct SiteVerificationInfo {
    /// Site verification state indicating the ownership and validity.
    #[prost(enumeration = "site_verification_info::SiteVerificationState", tag = "1")]
    pub site_verification_state: i32,
    /// Latest site verification time.
    #[prost(message, optional, tag = "2")]
    pub verify_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Nested message and enum types in `SiteVerificationInfo`.
pub mod site_verification_info {
    /// Site verification state.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum SiteVerificationState {
        /// Defaults to VERIFIED.
        Unspecified = 0,
        /// Site ownership verified.
        Verified = 1,
        /// Site ownership pending verification or verification failed.
        Unverified = 2,
        /// Site exempt from verification, e.g., a public website that opens to all.
        Exempted = 3,
    }
    impl SiteVerificationState {
        /// 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 {
                SiteVerificationState::Unspecified => {
                    "SITE_VERIFICATION_STATE_UNSPECIFIED"
                }
                SiteVerificationState::Verified => "VERIFIED",
                SiteVerificationState::Unverified => "UNVERIFIED",
                SiteVerificationState::Exempted => "EXEMPTED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "SITE_VERIFICATION_STATE_UNSPECIFIED" => Some(Self::Unspecified),
                "VERIFIED" => Some(Self::Verified),
                "UNVERIFIED" => Some(Self::Unverified),
                "EXEMPTED" => Some(Self::Exempted),
                _ => None,
            }
        }
    }
}
/// Request message for Recommend method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RecommendRequest {
    /// Required. Full resource name of a
    /// [ServingConfig][google.cloud.discoveryengine.v1alpha.ServingConfig]:
    /// `projects/*/locations/global/collections/*/engines/*/servingConfigs/*`, or
    /// `projects/*/locations/global/collections/*/dataStores/*/servingConfigs/*`
    ///
    /// One default serving config is created along with your recommendation engine
    /// creation. The engine ID is used as the ID of the default serving
    /// config. For example, for Engine
    /// `projects/*/locations/global/collections/*/engines/my-engine`, you can use
    /// `projects/*/locations/global/collections/*/engines/my-engine/servingConfigs/my-engine`
    /// for your
    /// [RecommendationService.Recommend][google.cloud.discoveryengine.v1alpha.RecommendationService.Recommend]
    /// requests.
    #[prost(string, tag = "1")]
    pub serving_config: ::prost::alloc::string::String,
    /// Required. Context about the user, what they are looking at and what action
    /// they took to trigger the Recommend request. Note that this user event
    /// detail won't be ingested to userEvent logs. Thus, a separate userEvent
    /// write request is required for event logging.
    ///
    /// Don't set
    /// [UserEvent.user_pseudo_id][google.cloud.discoveryengine.v1alpha.UserEvent.user_pseudo_id]
    /// or
    /// [UserEvent.user_info.user_id][google.cloud.discoveryengine.v1alpha.UserInfo.user_id]
    /// to the same fixed ID for different users. If you are trying to receive
    /// non-personalized recommendations (not recommended; this can negatively
    /// impact model performance), instead set
    /// [UserEvent.user_pseudo_id][google.cloud.discoveryengine.v1alpha.UserEvent.user_pseudo_id]
    /// to a random unique ID and leave
    /// [UserEvent.user_info.user_id][google.cloud.discoveryengine.v1alpha.UserInfo.user_id]
    /// unset.
    #[prost(message, optional, tag = "2")]
    pub user_event: ::core::option::Option<UserEvent>,
    /// Maximum number of results to return. Set this property
    /// to the number of recommendation results needed. If zero, the service
    /// chooses a reasonable default. The maximum allowed value is 100. Values
    /// above 100 are set to 100.
    #[prost(int32, tag = "3")]
    pub page_size: i32,
    /// Filter for restricting recommendation results with a length limit of 5,000
    /// characters. Currently, only filter expressions on the `filter_tags`
    /// attribute is supported.
    ///
    ///
    /// Examples:
    ///
    ///   * `(filter_tags: ANY("Red", "Blue") OR filter_tags: ANY("Hot", "Cold"))`
    ///   * `(filter_tags: ANY("Red", "Blue")) AND NOT (filter_tags: ANY("Green"))`
    ///
    /// If `attributeFilteringSyntax` is set to true under the `params` field, then
    /// attribute-based expressions are expected instead of the above described
    /// tag-based syntax. Examples:
    ///
    ///   * (launguage: ANY("en", "es")) AND NOT (categories: ANY("Movie"))
    ///   * (available: true) AND
    ///     (launguage: ANY("en", "es")) OR (categories: ANY("Movie"))
    ///
    /// If your filter blocks all results, the API returns generic
    /// (unfiltered) popular Documents. If you only want results strictly matching
    /// the filters, set `strictFiltering` to `true` in
    /// [RecommendRequest.params][google.cloud.discoveryengine.v1alpha.RecommendRequest.params]
    /// to receive empty results instead.
    ///
    /// Note that the API never returns
    /// [Document][google.cloud.discoveryengine.v1alpha.Document]s with
    /// `storageStatus` as `EXPIRED` or `DELETED` regardless of filter choices.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
    /// Use validate only mode for this recommendation query. If set to `true`, a
    /// fake model is used that returns arbitrary Document IDs.
    /// Note that the validate only mode should only be used for testing the API,
    /// or if the model is not ready.
    #[prost(bool, tag = "5")]
    pub validate_only: bool,
    /// Additional domain specific parameters for the recommendations.
    ///
    /// Allowed values:
    ///
    /// * `returnDocument`: Boolean. If set to `true`, the associated Document
    ///     object is returned in
    ///     [RecommendResponse.RecommendationResult.document][google.cloud.discoveryengine.v1alpha.RecommendResponse.RecommendationResult.document].
    /// * `returnScore`: Boolean. If set to true, the recommendation score
    ///     corresponding to each returned Document is set in
    ///     [RecommendResponse.RecommendationResult.metadata][google.cloud.discoveryengine.v1alpha.RecommendResponse.RecommendationResult.metadata].
    ///     The given score indicates the probability of a Document conversion given
    ///     the user's context and history.
    /// * `strictFiltering`: Boolean. True by default. If set to `false`, the
    /// service
    ///     returns generic (unfiltered) popular Documents instead of empty if
    ///     your filter blocks all recommendation results.
    /// * `diversityLevel`: String. Default empty. If set to be non-empty, then
    ///     it needs to be one of:
    ///      *  `no-diversity`
    ///      *  `low-diversity`
    ///      *  `medium-diversity`
    ///      *  `high-diversity`
    ///      *  `auto-diversity`
    ///     This gives request-level control and adjusts recommendation results
    ///     based on Document category.
    /// * `attributeFilteringSyntax`: Boolean. False by default. If set to true,
    ///     the `filter` field is interpreted according to the new,
    ///     attribute-based syntax.
    #[prost(btree_map = "string, message", tag = "6")]
    pub params: ::prost::alloc::collections::BTreeMap<
        ::prost::alloc::string::String,
        ::prost_types::Value,
    >,
    /// The user labels applied to a resource must meet the following requirements:
    ///
    /// * Each resource can have multiple labels, up to a maximum of 64.
    /// * Each label must be a key-value pair.
    /// * Keys have a minimum length of 1 character and a maximum length of 63
    ///    characters and cannot be empty. Values can be empty and have a maximum
    ///    length of 63 characters.
    /// * Keys and values can contain only lowercase letters, numeric characters,
    ///    underscores, and dashes. All characters must use UTF-8 encoding, and
    ///    international characters are allowed.
    /// * The key portion of a label must be unique. However, you can use the same
    ///    key with multiple resources.
    /// * Keys must start with a lowercase letter or international character.
    ///
    /// See [Requirements for
    /// labels](<https://cloud.google.com/resource-manager/docs/creating-managing-labels#requirements>)
    /// for more details.
    #[prost(btree_map = "string, string", tag = "8")]
    pub user_labels: ::prost::alloc::collections::BTreeMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
/// Response message for Recommend method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RecommendResponse {
    /// A list of recommended Documents. The order represents the ranking (from the
    /// most relevant Document to the least).
    #[prost(message, repeated, tag = "1")]
    pub results: ::prost::alloc::vec::Vec<recommend_response::RecommendationResult>,
    /// A unique attribution token. This should be included in the
    /// [UserEvent][google.cloud.discoveryengine.v1alpha.UserEvent] logs resulting
    /// from this recommendation, which enables accurate attribution of
    /// recommendation model performance.
    #[prost(string, tag = "2")]
    pub attribution_token: ::prost::alloc::string::String,
    /// IDs of documents in the request that were missing from the default Branch
    /// associated with the requested ServingConfig.
    #[prost(string, repeated, tag = "3")]
    pub missing_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// True if
    /// [RecommendRequest.validate_only][google.cloud.discoveryengine.v1alpha.RecommendRequest.validate_only]
    /// was set.
    #[prost(bool, tag = "4")]
    pub validate_only: bool,
}
/// Nested message and enum types in `RecommendResponse`.
pub mod recommend_response {
    /// RecommendationResult represents a generic recommendation result with
    /// associated metadata.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RecommendationResult {
        /// Resource ID of the recommended Document.
        #[prost(string, tag = "1")]
        pub id: ::prost::alloc::string::String,
        /// Set if `returnDocument` is set to true in
        /// [RecommendRequest.params][google.cloud.discoveryengine.v1alpha.RecommendRequest.params].
        #[prost(message, optional, tag = "2")]
        pub document: ::core::option::Option<super::Document>,
        /// Additional Document metadata or annotations.
        ///
        /// Possible values:
        ///
        /// * `score`: Recommendation score in double value. Is set if
        ///    `returnScore` is set to true in
        ///    [RecommendRequest.params][google.cloud.discoveryengine.v1alpha.RecommendRequest.params].
        #[prost(btree_map = "string, message", tag = "3")]
        pub metadata: ::prost::alloc::collections::BTreeMap<
            ::prost::alloc::string::String,
            ::prost_types::Value,
        >,
    }
}
/// Generated client implementations.
pub mod recommendation_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for making recommendations.
    #[derive(Debug, Clone)]
    pub struct RecommendationServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl<T> RecommendationServiceClient<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,
        ) -> RecommendationServiceClient<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,
        {
            RecommendationServiceClient::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
        }
        /// Makes a recommendation, which requires a contextual user event.
        pub async fn recommend(
            &mut self,
            request: impl tonic::IntoRequest<super::RecommendRequest>,
        ) -> std::result::Result<
            tonic::Response<super::RecommendResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.RecommendationService/Recommend",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.RecommendationService",
                        "Recommend",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Defines circumstances to be checked before allowing a behavior
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Condition {
    /// Search only
    /// A list of terms to match the query on.
    ///
    /// Maximum of 10 query terms.
    #[prost(message, repeated, tag = "2")]
    pub query_terms: ::prost::alloc::vec::Vec<condition::QueryTerm>,
    /// Range of time(s) specifying when condition is active.
    ///
    /// Maximum of 10 time ranges.
    #[prost(message, repeated, tag = "3")]
    pub active_time_range: ::prost::alloc::vec::Vec<condition::TimeRange>,
}
/// Nested message and enum types in `Condition`.
pub mod condition {
    /// Matcher for search request query
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct QueryTerm {
        /// The specific query value to match against
        ///
        /// Must be lowercase, must be UTF-8.
        /// Can have at most 3 space separated terms if full_match is true.
        /// Cannot be an empty string.
        /// Maximum length of 5000 characters.
        #[prost(string, tag = "1")]
        pub value: ::prost::alloc::string::String,
        /// Whether the search query needs to exactly match the query term.
        #[prost(bool, tag = "2")]
        pub full_match: bool,
    }
    /// Used for time-dependent conditions.
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct TimeRange {
        /// Start of time range.
        ///
        /// Range is inclusive.
        #[prost(message, optional, tag = "1")]
        pub start_time: ::core::option::Option<::prost_types::Timestamp>,
        /// End of time range.
        ///
        /// Range is inclusive.
        /// Must be in the future.
        #[prost(message, optional, tag = "2")]
        pub end_time: ::core::option::Option<::prost_types::Timestamp>,
    }
}
/// Defines a conditioned behavior to employ during serving.
/// Must be attached to a
/// [ServingConfig][google.cloud.discoveryengine.v1alpha.ServingConfig] to be
/// considered at serving time. Permitted actions dependent on `SolutionType`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Control {
    /// Immutable. Fully qualified name
    /// `projects/*/locations/global/dataStore/*/controls/*`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. Human readable name. The identifier used in UI views.
    ///
    /// Must be UTF-8 encoded string. Length limit is 128 characters.
    /// Otherwise an INVALID ARGUMENT error is thrown.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// Output only. List of all
    /// [ServingConfig][google.cloud.discoveryengine.v1alpha.ServingConfig] IDs
    /// this control is attached to. May take up to 10 minutes to update after
    /// changes.
    #[prost(string, repeated, tag = "3")]
    pub associated_serving_config_ids: ::prost::alloc::vec::Vec<
        ::prost::alloc::string::String,
    >,
    /// Required. Immutable. What solution the control belongs to.
    ///
    /// Must be compatible with vertical of resource.
    /// Otherwise an INVALID ARGUMENT error is thrown.
    #[prost(enumeration = "SolutionType", tag = "4")]
    pub solution_type: i32,
    /// Specifies the use case for the control.
    /// Affects what condition fields can be set.
    /// Only applies to
    /// [SOLUTION_TYPE_SEARCH][google.cloud.discoveryengine.v1alpha.SolutionType.SOLUTION_TYPE_SEARCH].
    /// Currently only allow one use case per control.
    /// Must be set when solution_type is
    /// [SolutionType.SOLUTION_TYPE_SEARCH][google.cloud.discoveryengine.v1alpha.SolutionType.SOLUTION_TYPE_SEARCH].
    #[prost(enumeration = "SearchUseCase", repeated, tag = "8")]
    pub use_cases: ::prost::alloc::vec::Vec<i32>,
    /// Determines when the associated action will trigger.
    ///
    /// Omit to always apply the action.
    /// Currently only a single condition may be specified.
    /// Otherwise an INVALID ARGUMENT error is thrown.
    #[prost(message, repeated, tag = "5")]
    pub conditions: ::prost::alloc::vec::Vec<Condition>,
    /// Actions are restricted by Vertical and Solution
    ///
    /// Required.
    #[prost(oneof = "control::Action", tags = "6, 7, 9, 10")]
    pub action: ::core::option::Option<control::Action>,
}
/// Nested message and enum types in `Control`.
pub mod control {
    /// Adjusts order of products in returned list.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct BoostAction {
        /// Required. Strength of the boost, which should be in \[-1, 1\]. Negative
        /// boost means demotion. Default is 0.0 (No-op).
        #[prost(float, tag = "1")]
        pub boost: f32,
        /// Required. Specifies which products to apply the boost to.
        ///
        /// If no filter is provided all products will be boosted (No-op).
        /// Syntax documentation:
        /// <https://cloud.google.com/retail/docs/filter-and-order>
        /// Maximum length is 5000 characters.
        /// Otherwise an INVALID ARGUMENT error is thrown.
        #[prost(string, tag = "2")]
        pub filter: ::prost::alloc::string::String,
        /// Required. Specifies which data store's documents can be boosted by this
        /// control. Full data store name e.g.
        /// projects/123/locations/global/collections/default_collection/dataStores/default_data_store
        #[prost(string, tag = "3")]
        pub data_store: ::prost::alloc::string::String,
    }
    /// Specified which products may be included in results.
    /// Uses same filter as boost.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct FilterAction {
        /// Required. A filter to apply on the matching condition results.
        ///
        /// Required
        /// Syntax documentation:
        /// <https://cloud.google.com/retail/docs/filter-and-order>
        /// Maximum length is 5000 characters. Otherwise an INVALID
        /// ARGUMENT error is thrown.
        #[prost(string, tag = "1")]
        pub filter: ::prost::alloc::string::String,
        /// Required. Specifies which data store's documents can be filtered by this
        /// control. Full data store name e.g.
        /// projects/123/locations/global/collections/default_collection/dataStores/default_data_store
        #[prost(string, tag = "2")]
        pub data_store: ::prost::alloc::string::String,
    }
    /// Redirects a shopper to the provided URI.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RedirectAction {
        /// Required. The URI to which the shopper will be redirected.
        ///
        /// Required.
        /// URI must have length equal or less than 2000 characters.
        /// Otherwise an INVALID ARGUMENT error is thrown.
        #[prost(string, tag = "1")]
        pub redirect_uri: ::prost::alloc::string::String,
    }
    /// Creates a set of terms that will act as synonyms of one another.
    ///
    /// Example: "happy" will also be considered as "glad", "glad" will also be
    /// considered as "happy".
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct SynonymsAction {
        /// Defines a set of synonyms.
        /// Can specify up to 100 synonyms.
        /// Must specify at least 2 synonyms. Otherwise an INVALID ARGUMENT error is
        /// thrown.
        #[prost(string, repeated, tag = "1")]
        pub synonyms: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    }
    /// Actions are restricted by Vertical and Solution
    ///
    /// Required.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Action {
        /// Defines a boost-type control
        #[prost(message, tag = "6")]
        BoostAction(BoostAction),
        /// Defines a filter-type control
        /// Currently not supported by Recommendation
        #[prost(message, tag = "7")]
        FilterAction(FilterAction),
        /// Defines a redirect-type control.
        #[prost(message, tag = "9")]
        RedirectAction(RedirectAction),
        /// Treats a group of terms as synonyms of one another.
        #[prost(message, tag = "10")]
        SynonymsAction(SynonymsAction),
    }
}
/// Request for CreateControl method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateControlRequest {
    /// Required. Full resource name of parent data store. Format:
    /// `projects/{project_number}/locations/{location_id}/collections/{collection_id}/dataStores/{data_store_id}`
    /// or
    /// `projects/{project_number}/locations/{location_id}/collections/{collection_id}/engines/{engine_id}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The Control to create.
    #[prost(message, optional, tag = "2")]
    pub control: ::core::option::Option<Control>,
    /// Required. The ID to use for the Control, which will become the final
    /// component of the Control's resource name.
    ///
    /// This value must be within 1-63 characters.
    /// Valid characters are /[a-z][0-9]-_/.
    #[prost(string, tag = "3")]
    pub control_id: ::prost::alloc::string::String,
}
/// Request for UpdateControl method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateControlRequest {
    /// Required. The Control to update.
    #[prost(message, optional, tag = "1")]
    pub control: ::core::option::Option<Control>,
    /// Optional. Indicates which fields in the provided
    /// [Control][google.cloud.discoveryengine.v1alpha.Control] to update. The
    /// following are NOT supported:
    ///
    /// * [Control.name][google.cloud.discoveryengine.v1alpha.Control.name]
    /// * [Control.solution_type][google.cloud.discoveryengine.v1alpha.Control.solution_type]
    ///
    /// If not set or empty, all supported fields are updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request for DeleteControl method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteControlRequest {
    /// Required. The resource name of the Control to delete. Format:
    /// `projects/{project_number}/locations/{location_id}/collections/{collection_id}/dataStores/{data_store_id}/controls/{control_id}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request for GetControl method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetControlRequest {
    /// Required. The resource name of the Control to get. Format:
    /// `projects/{project_number}/locations/{location_id}/collections/{collection_id}/dataStores/{data_store_id}/controls/{control_id}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request for ListControls method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListControlsRequest {
    /// Required. The data store resource name. Format:
    /// `projects/{project_number}/locations/{location_id}/collections/{collection_id}/dataStores/{data_store_id}`
    /// or
    /// `projects/{project_number}/locations/{location_id}/collections/{collection_id}/engines/{engine_id}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. Maximum number of results to return. If unspecified, defaults
    /// to 50. Max allowed value is 1000.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. A page token, received from a previous `ListControls` call.
    /// Provide this to retrieve the subsequent page.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Optional. A filter to apply on the list results. Supported features:
    ///
    /// * List all the products under the parent branch if
    /// [filter][google.cloud.discoveryengine.v1alpha.ListControlsRequest.filter]
    /// is unset. Currently this field is unsupported.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
}
/// Response for ListControls method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListControlsResponse {
    /// All the Controls for a given data store.
    #[prost(message, repeated, tag = "1")]
    pub controls: ::prost::alloc::vec::Vec<Control>,
    /// Pagination token, if not returned indicates the last page.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod control_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for performing CRUD operations on Controls.
    /// Controls allow for custom logic to be implemented in the serving path.
    /// Controls need to be attached to a Serving Config to be considered during a
    /// request.
    #[derive(Debug, Clone)]
    pub struct ControlServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl<T> ControlServiceClient<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,
        ) -> ControlServiceClient<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,
        {
            ControlServiceClient::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
        }
        /// Creates a Control.
        ///
        /// By default 1000 controls are allowed for a data store.
        /// A request can be submitted to adjust this limit.
        /// If the [Control][google.cloud.discoveryengine.v1alpha.Control] to create
        /// already exists, an ALREADY_EXISTS error is returned.
        pub async fn create_control(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateControlRequest>,
        ) -> std::result::Result<tonic::Response<super::Control>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.ControlService/CreateControl",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.ControlService",
                        "CreateControl",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes a Control.
        ///
        /// If the [Control][google.cloud.discoveryengine.v1alpha.Control] to delete
        /// does not exist, a NOT_FOUND error is returned.
        pub async fn delete_control(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteControlRequest>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.ControlService/DeleteControl",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.ControlService",
                        "DeleteControl",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates a Control.
        ///
        /// [Control][google.cloud.discoveryengine.v1alpha.Control] action type cannot
        /// be changed. If the [Control][google.cloud.discoveryengine.v1alpha.Control]
        /// to update does not exist, a NOT_FOUND error is returned.
        pub async fn update_control(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateControlRequest>,
        ) -> std::result::Result<tonic::Response<super::Control>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.ControlService/UpdateControl",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.ControlService",
                        "UpdateControl",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets a Control.
        pub async fn get_control(
            &mut self,
            request: impl tonic::IntoRequest<super::GetControlRequest>,
        ) -> std::result::Result<tonic::Response<super::Control>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.ControlService/GetControl",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.ControlService",
                        "GetControl",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists all Controls by their parent
        /// [DataStore][google.cloud.discoveryengine.v1alpha.DataStore].
        pub async fn list_controls(
            &mut self,
            request: impl tonic::IntoRequest<super::ListControlsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListControlsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.ControlService/ListControls",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.ControlService",
                        "ListControls",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Metadata and configurations for a Google Cloud project in the service.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Project {
    /// Output only. Full resource name of the project, for example
    /// `projects/{project_number}`.
    /// Note that when making requests, project number and project id are both
    /// acceptable, but the server will always respond in project number.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. The timestamp when this project is created.
    #[prost(message, optional, tag = "2")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The timestamp when this project is successfully provisioned.
    /// Empty value means this project is still provisioning and is not ready for
    /// use.
    #[prost(message, optional, tag = "3")]
    pub provision_completion_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. A map of terms of services. The key is the `id` of
    /// [ServiceTerms][google.cloud.discoveryengine.v1alpha.Project.ServiceTerms].
    #[prost(btree_map = "string, message", tag = "4")]
    pub service_terms_map: ::prost::alloc::collections::BTreeMap<
        ::prost::alloc::string::String,
        project::ServiceTerms,
    >,
}
/// Nested message and enum types in `Project`.
pub mod project {
    /// Metadata about the terms of service.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ServiceTerms {
        /// The unique identifier of this terms of service.
        /// Available terms:
        ///
        /// * `GA_DATA_USE_TERMS`: [Terms for data
        /// use](<https://cloud.google.com/retail/data-use-terms>). When using this as
        /// `id`, the acceptable
        /// [version][google.cloud.discoveryengine.v1alpha.Project.ServiceTerms.version]
        /// to provide is `2022-11-23`.
        #[prost(string, tag = "1")]
        pub id: ::prost::alloc::string::String,
        /// The version string of the terms of service.
        /// For acceptable values, see the comments for
        /// [id][google.cloud.discoveryengine.v1alpha.Project.ServiceTerms.id] above.
        #[prost(string, tag = "2")]
        pub version: ::prost::alloc::string::String,
        /// Whether the project has accepted/rejected the service terms or it is
        /// still pending.
        #[prost(enumeration = "service_terms::State", tag = "4")]
        pub state: i32,
        /// The last time when the project agreed to the terms of service.
        #[prost(message, optional, tag = "5")]
        pub accept_time: ::core::option::Option<::prost_types::Timestamp>,
        /// The last time when the project declined or revoked the agreement to terms
        /// of service.
        #[prost(message, optional, tag = "6")]
        pub decline_time: ::core::option::Option<::prost_types::Timestamp>,
    }
    /// Nested message and enum types in `ServiceTerms`.
    pub mod service_terms {
        /// The agreement states this terms of service.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum State {
            /// The default value of the enum. This value is not actually used.
            Unspecified = 0,
            /// The project has given consent to the terms of service.
            TermsAccepted = 1,
            /// The project is pending to review and accept the terms of service.
            TermsPending = 2,
            /// The project has declined or revoked the agreement to terms of service.
            TermsDeclined = 3,
        }
        impl State {
            /// 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 {
                    State::Unspecified => "STATE_UNSPECIFIED",
                    State::TermsAccepted => "TERMS_ACCEPTED",
                    State::TermsPending => "TERMS_PENDING",
                    State::TermsDeclined => "TERMS_DECLINED",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "STATE_UNSPECIFIED" => Some(Self::Unspecified),
                    "TERMS_ACCEPTED" => Some(Self::TermsAccepted),
                    "TERMS_PENDING" => Some(Self::TermsPending),
                    "TERMS_DECLINED" => Some(Self::TermsDeclined),
                    _ => None,
                }
            }
        }
    }
}
/// An evaluation is a single execution (or run) of an evaluation process. It
/// encapsulates the state of the evaluation and the resulting data.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Evaluation {
    /// Identifier. The full resource name of the
    /// [Evaluation][google.cloud.discoveryengine.v1alpha.Evaluation], in the
    /// format of
    /// `projects/{project}/locations/{location}/evaluations/{evaluation}`.
    ///
    /// This field must be a UTF-8 encoded string with a length limit of 1024
    /// characters.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. The specification of the evaluation.
    #[prost(message, optional, tag = "2")]
    pub evaluation_spec: ::core::option::Option<evaluation::EvaluationSpec>,
    /// Output only. The metrics produced by the evaluation, averaged across all
    /// [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery]s in the
    /// [SampleQuerySet][google.cloud.discoveryengine.v1alpha.SampleQuerySet].
    ///
    /// Only populated when the evaluation's state is SUCCEEDED.
    #[prost(message, optional, tag = "3")]
    pub quality_metrics: ::core::option::Option<QualityMetrics>,
    /// Output only. The state of the evaluation.
    #[prost(enumeration = "evaluation::State", tag = "4")]
    pub state: i32,
    /// Output only. The error that occurred during evaluation. Only populated when
    /// the evaluation's state is FAILED.
    #[prost(message, optional, tag = "5")]
    pub error: ::core::option::Option<super::super::super::rpc::Status>,
    /// Output only. Timestamp the
    /// [Evaluation][google.cloud.discoveryengine.v1alpha.Evaluation] was created
    /// at.
    #[prost(message, optional, tag = "6")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Timestamp the
    /// [Evaluation][google.cloud.discoveryengine.v1alpha.Evaluation] was completed
    /// at.
    #[prost(message, optional, tag = "7")]
    pub end_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. A sample of errors encountered while processing the request.
    #[prost(message, repeated, tag = "8")]
    pub error_samples: ::prost::alloc::vec::Vec<super::super::super::rpc::Status>,
}
/// Nested message and enum types in `Evaluation`.
pub mod evaluation {
    /// Describes the specification of the evaluation.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct EvaluationSpec {
        /// Required. The specification of the query set.
        #[prost(message, optional, tag = "1")]
        pub query_set_spec: ::core::option::Option<evaluation_spec::QuerySetSpec>,
        /// The search specification.
        #[prost(oneof = "evaluation_spec::SearchSpec", tags = "2")]
        pub search_spec: ::core::option::Option<evaluation_spec::SearchSpec>,
    }
    /// Nested message and enum types in `EvaluationSpec`.
    pub mod evaluation_spec {
        /// Describes the specification of the query set.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct QuerySetSpec {
            /// Required. The full resource name of the
            /// [SampleQuerySet][google.cloud.discoveryengine.v1alpha.SampleQuerySet]
            /// used for the evaluation, in the format of
            /// `projects/{project}/locations/{location}/sampleQuerySets/{sampleQuerySet}`.
            #[prost(string, tag = "1")]
            pub sample_query_set: ::prost::alloc::string::String,
        }
        /// The search specification.
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum SearchSpec {
            /// Required. The search request that is used to perform the evaluation.
            ///
            /// Only the following fields within SearchRequest are supported; if any
            /// other fields are provided, an UNSUPPORTED error will be returned:
            ///
            /// * [SearchRequest.serving_config][google.cloud.discoveryengine.v1alpha.SearchRequest.serving_config]
            /// * [SearchRequest.branch][google.cloud.discoveryengine.v1alpha.SearchRequest.branch]
            /// * [SearchRequest.canonical_filter][google.cloud.discoveryengine.v1alpha.SearchRequest.canonical_filter]
            /// * [SearchRequest.query_expansion_spec][google.cloud.discoveryengine.v1alpha.SearchRequest.query_expansion_spec]
            /// * [SearchRequest.spell_correction_spec][google.cloud.discoveryengine.v1alpha.SearchRequest.spell_correction_spec]
            /// * [SearchRequest.content_search_spec][google.cloud.discoveryengine.v1alpha.SearchRequest.content_search_spec]
            /// * [SearchRequest.user_pseudo_id][google.cloud.discoveryengine.v1alpha.SearchRequest.user_pseudo_id]
            #[prost(message, tag = "2")]
            SearchRequest(super::super::SearchRequest),
        }
    }
    /// Describes the state of an evaluation.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        /// The evaluation is unspecified.
        Unspecified = 0,
        /// The service is preparing to run the evaluation.
        Pending = 1,
        /// The evaluation is in progress.
        Running = 2,
        /// The evaluation completed successfully.
        Succeeded = 3,
        /// The evaluation failed.
        Failed = 4,
    }
    impl State {
        /// 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 {
                State::Unspecified => "STATE_UNSPECIFIED",
                State::Pending => "PENDING",
                State::Running => "RUNNING",
                State::Succeeded => "SUCCEEDED",
                State::Failed => "FAILED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATE_UNSPECIFIED" => Some(Self::Unspecified),
                "PENDING" => Some(Self::Pending),
                "RUNNING" => Some(Self::Running),
                "SUCCEEDED" => Some(Self::Succeeded),
                "FAILED" => Some(Self::Failed),
                _ => None,
            }
        }
    }
}
/// Describes the metrics produced by the evaluation.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct QualityMetrics {
    /// Recall per document, at various top-k cutoff levels.
    ///
    /// Recall is the fraction of relevant documents retrieved out of all
    /// relevant documents.
    ///
    /// Example (top-5):
    ///   * For a single
    ///   [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery], If 3 out
    ///   of 5 relevant documents are retrieved in the top-5, recall@5 = 3/5 = 0.6
    #[prost(message, optional, tag = "1")]
    pub doc_recall: ::core::option::Option<quality_metrics::TopkMetrics>,
    /// Precision per document, at various top-k cutoff levels.
    ///
    /// Precision is the fraction of retrieved documents that are relevant.
    ///
    /// Example (top-5):
    ///   * For a single
    ///   [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery], If 4 out
    ///   of 5 retrieved documents in the top-5 are relevant, precision@5 = 4/5 =
    ///   0.8
    #[prost(message, optional, tag = "2")]
    pub doc_precision: ::core::option::Option<quality_metrics::TopkMetrics>,
    /// Normalized discounted cumulative gain (NDCG) per document, at various top-k
    /// cutoff levels.
    ///
    /// NDCG measures the ranking quality, giving higher relevance to top
    /// results.
    ///
    /// Example (top-3):
    ///   Suppose [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery]
    ///   with three retrieved documents (D1, D2, D3) and binary relevance
    ///   judgements (1 for relevant, 0 for not relevant):
    ///
    ///    Retrieved:  \[D3 (0), D1 (1), D2 (1)\]
    ///    Ideal:      \[D1 (1), D2 (1), D3 (0)\]
    ///
    ///    Calculate NDCG@3 for each
    ///    [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery]:
    ///     * DCG@3: 0/log2(1+1) + 1/log2(2+1) + 1/log2(3+1) = 1.13
    ///     * Ideal DCG@3: 1/log2(1+1) + 1/log2(2+1) + 0/log2(3+1) = 1.63
    ///     * NDCG@3: 1.13/1.63 = 0.693
    #[prost(message, optional, tag = "3")]
    pub doc_ndcg: ::core::option::Option<quality_metrics::TopkMetrics>,
    /// Recall per page, at various top-k cutoff levels.
    ///
    /// Recall is the fraction of relevant pages retrieved out of all relevant
    /// pages.
    ///
    /// Example (top-5):
    ///   * For a single
    ///   [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery], if 3 out
    ///   of 5 relevant pages are retrieved in the top-5, recall@5 = 3/5 = 0.6
    #[prost(message, optional, tag = "4")]
    pub page_recall: ::core::option::Option<quality_metrics::TopkMetrics>,
    /// Normalized discounted cumulative gain (NDCG) per page, at various top-k
    /// cutoff levels.
    ///
    /// NDCG measures the ranking quality, giving higher relevance to top
    /// results.
    ///
    /// Example (top-3):
    ///   Suppose [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery]
    ///   with three retrieved pages (P1, P2, P3) and binary relevance judgements (1
    ///   for relevant, 0 for not relevant):
    ///
    ///    Retrieved:  \[P3 (0), P1 (1), P2 (1)\]
    ///    Ideal:      \[P1 (1), P2 (1), P3 (0)\]
    ///
    ///    Calculate NDCG@3 for
    ///    [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery]:
    ///     * DCG@3: 0/log2(1+1) + 1/log2(2+1) + 1/log2(3+1) = 1.13
    ///     * Ideal DCG@3: 1/log2(1+1) + 1/log2(2+1) + 0/log2(3+1) = 1.63
    ///     * NDCG@3: 1.13/1.63 = 0.693
    #[prost(message, optional, tag = "5")]
    pub page_ndcg: ::core::option::Option<quality_metrics::TopkMetrics>,
}
/// Nested message and enum types in `QualityMetrics`.
pub mod quality_metrics {
    /// Stores the metric values at specific top-k levels.
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct TopkMetrics {
        /// The top-1 value.
        #[prost(double, tag = "1")]
        pub top_1: f64,
        /// The top-3 value.
        #[prost(double, tag = "2")]
        pub top_3: f64,
        /// The top-5 value.
        #[prost(double, tag = "3")]
        pub top_5: f64,
        /// The top-10 value.
        #[prost(double, tag = "4")]
        pub top_10: f64,
    }
}
/// Request message for
/// [EvaluationService.GetEvaluation][google.cloud.discoveryengine.v1alpha.EvaluationService.GetEvaluation]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetEvaluationRequest {
    /// Required. Full resource name of
    /// [Evaluation][google.cloud.discoveryengine.v1alpha.Evaluation], such as
    /// `projects/{project}/locations/{location}/evaluations/{evaluation}`.
    ///
    /// If the caller does not have permission to access the
    /// [Evaluation][google.cloud.discoveryengine.v1alpha.Evaluation], regardless
    /// of whether or not it exists, a PERMISSION_DENIED error is returned.
    ///
    /// If the requested
    /// [Evaluation][google.cloud.discoveryengine.v1alpha.Evaluation] does not
    /// exist, a NOT_FOUND error is returned.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for
/// [EvaluationService.ListEvaluations][google.cloud.discoveryengine.v1alpha.EvaluationService.ListEvaluations]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListEvaluationsRequest {
    /// Required. The parent location resource name, such as
    /// `projects/{project}/locations/{location}`.
    ///
    /// If the caller does not have permission to list
    /// [Evaluation][google.cloud.discoveryengine.v1alpha.Evaluation]s under this
    /// location, regardless of whether or not this location exists, a
    /// `PERMISSION_DENIED` error is returned.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Maximum number of
    /// [Evaluation][google.cloud.discoveryengine.v1alpha.Evaluation]s to return.
    /// If unspecified, defaults to 100. The maximum allowed value is 1000. Values
    /// above 1000 will be coerced to 1000.
    ///
    /// If this field is negative, an `INVALID_ARGUMENT` error is returned.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// A page token
    /// [ListEvaluationsResponse.next_page_token][google.cloud.discoveryengine.v1alpha.ListEvaluationsResponse.next_page_token],
    /// received from a previous
    /// [EvaluationService.ListEvaluations][google.cloud.discoveryengine.v1alpha.EvaluationService.ListEvaluations]
    /// call. Provide this to retrieve the subsequent page.
    ///
    /// When paginating, all other parameters provided to
    /// [EvaluationService.ListEvaluations][google.cloud.discoveryengine.v1alpha.EvaluationService.ListEvaluations]
    /// must match the call that provided the page token. Otherwise, an
    /// `INVALID_ARGUMENT` error is returned.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// Response message for
/// [EvaluationService.ListEvaluations][google.cloud.discoveryengine.v1alpha.EvaluationService.ListEvaluations]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListEvaluationsResponse {
    /// The [Evaluation][google.cloud.discoveryengine.v1alpha.Evaluation]s.
    #[prost(message, repeated, tag = "1")]
    pub evaluations: ::prost::alloc::vec::Vec<Evaluation>,
    /// A token that can be sent as
    /// [ListEvaluationsRequest.page_token][google.cloud.discoveryengine.v1alpha.ListEvaluationsRequest.page_token]
    /// to retrieve the next page. If this field is omitted, there are no
    /// subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for
/// [EvaluationService.CreateEvaluation][google.cloud.discoveryengine.v1alpha.EvaluationService.CreateEvaluation]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateEvaluationRequest {
    /// Required. The parent resource name, such as
    /// `projects/{project}/locations/{location}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The [Evaluation][google.cloud.discoveryengine.v1alpha.Evaluation]
    /// to create.
    #[prost(message, optional, tag = "2")]
    pub evaluation: ::core::option::Option<Evaluation>,
}
/// Metadata for
/// [EvaluationService.CreateEvaluation][google.cloud.discoveryengine.v1alpha.EvaluationService.CreateEvaluation]
/// method.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct CreateEvaluationMetadata {}
/// Request message for
/// [EvaluationService.ListEvaluationResults][google.cloud.discoveryengine.v1alpha.EvaluationService.ListEvaluationResults]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListEvaluationResultsRequest {
    /// Required. The evaluation resource name, such as
    /// `projects/{project}/locations/{location}/evaluations/{evaluation}`.
    ///
    /// If the caller does not have permission to list [EvaluationResult][]
    /// under this evaluation, regardless of whether or not this evaluation
    /// set exists, a `PERMISSION_DENIED` error is returned.
    #[prost(string, tag = "1")]
    pub evaluation: ::prost::alloc::string::String,
    /// Maximum number of [EvaluationResult][] to return. If unspecified,
    /// defaults to 100. The maximum allowed value is 1000. Values above 1000 will
    /// be coerced to 1000.
    ///
    /// If this field is negative, an `INVALID_ARGUMENT` error is returned.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// A page token
    /// [ListEvaluationResultsResponse.next_page_token][google.cloud.discoveryengine.v1alpha.ListEvaluationResultsResponse.next_page_token],
    /// received from a previous
    /// [EvaluationService.ListEvaluationResults][google.cloud.discoveryengine.v1alpha.EvaluationService.ListEvaluationResults]
    /// call. Provide this to retrieve the subsequent page.
    ///
    /// When paginating, all other parameters provided to
    /// [EvaluationService.ListEvaluationResults][google.cloud.discoveryengine.v1alpha.EvaluationService.ListEvaluationResults]
    /// must match the call that provided the page token. Otherwise, an
    /// `INVALID_ARGUMENT` error is returned.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// Response message for
/// [EvaluationService.ListEvaluationResults][google.cloud.discoveryengine.v1alpha.EvaluationService.ListEvaluationResults]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListEvaluationResultsResponse {
    /// The
    /// [EvaluationResult][google.cloud.discoveryengine.v1alpha.ListEvaluationResultsResponse.EvaluationResult]s.
    #[prost(message, repeated, tag = "1")]
    pub evaluation_results: ::prost::alloc::vec::Vec<
        list_evaluation_results_response::EvaluationResult,
    >,
    /// A token that can be sent as
    /// [ListEvaluationResultsRequest.page_token][google.cloud.discoveryengine.v1alpha.ListEvaluationResultsRequest.page_token]
    /// to retrieve the next page. If this field is omitted, there are no
    /// subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Nested message and enum types in `ListEvaluationResultsResponse`.
pub mod list_evaluation_results_response {
    /// Represents the results of an evaluation for a single
    /// [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery].
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct EvaluationResult {
        /// Output only. The
        /// [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery] that was
        /// evaluated.
        #[prost(message, optional, tag = "1")]
        pub sample_query: ::core::option::Option<super::SampleQuery>,
        /// Output only. The metrics produced by the evaluation, for a given
        /// [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery].
        #[prost(message, optional, tag = "2")]
        pub quality_metrics: ::core::option::Option<super::QualityMetrics>,
    }
}
/// Generated client implementations.
pub mod evaluation_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for managing
    /// [Evaluation][google.cloud.discoveryengine.v1alpha.Evaluation]s,
    #[derive(Debug, Clone)]
    pub struct EvaluationServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl<T> EvaluationServiceClient<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,
        ) -> EvaluationServiceClient<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,
        {
            EvaluationServiceClient::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
        }
        /// Gets a [Evaluation][google.cloud.discoveryengine.v1alpha.Evaluation].
        pub async fn get_evaluation(
            &mut self,
            request: impl tonic::IntoRequest<super::GetEvaluationRequest>,
        ) -> std::result::Result<tonic::Response<super::Evaluation>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.EvaluationService/GetEvaluation",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.EvaluationService",
                        "GetEvaluation",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets a list of
        /// [Evaluation][google.cloud.discoveryengine.v1alpha.Evaluation]s.
        pub async fn list_evaluations(
            &mut self,
            request: impl tonic::IntoRequest<super::ListEvaluationsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListEvaluationsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.EvaluationService/ListEvaluations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.EvaluationService",
                        "ListEvaluations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a [Evaluation][google.cloud.discoveryengine.v1alpha.Evaluation].
        ///
        /// Upon creation, the evaluation will be automatically triggered and begin
        /// execution.
        pub async fn create_evaluation(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateEvaluationRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.EvaluationService/CreateEvaluation",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.EvaluationService",
                        "CreateEvaluation",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets a list of results for a given a
        /// [Evaluation][google.cloud.discoveryengine.v1alpha.Evaluation].
        pub async fn list_evaluation_results(
            &mut self,
            request: impl tonic::IntoRequest<super::ListEvaluationResultsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListEvaluationResultsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.EvaluationService/ListEvaluationResults",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.EvaluationService",
                        "ListEvaluationResults",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Defines an answer.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Answer {
    /// Immutable. Fully qualified name
    /// `projects/{project}/locations/global/collections/{collection}/engines/{engine}/sessions/*/answers/*`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The state of the answer generation.
    #[prost(enumeration = "answer::State", tag = "2")]
    pub state: i32,
    /// The textual answer.
    #[prost(string, tag = "3")]
    pub answer_text: ::prost::alloc::string::String,
    /// Citations.
    #[prost(message, repeated, tag = "4")]
    pub citations: ::prost::alloc::vec::Vec<answer::Citation>,
    /// References.
    #[prost(message, repeated, tag = "5")]
    pub references: ::prost::alloc::vec::Vec<answer::Reference>,
    /// Suggested related questions.
    #[prost(string, repeated, tag = "6")]
    pub related_questions: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Answer generation steps.
    #[prost(message, repeated, tag = "7")]
    pub steps: ::prost::alloc::vec::Vec<answer::Step>,
    /// Query understanding information.
    #[prost(message, optional, tag = "10")]
    pub query_understanding_info: ::core::option::Option<answer::QueryUnderstandingInfo>,
    /// Additional answer-skipped reasons. This provides the reason for ignored
    /// cases. If nothing is skipped, this field is not set.
    #[prost(enumeration = "answer::AnswerSkippedReason", repeated, tag = "11")]
    pub answer_skipped_reasons: ::prost::alloc::vec::Vec<i32>,
    /// Output only. Answer creation timestamp.
    #[prost(message, optional, tag = "8")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Answer completed timestamp.
    #[prost(message, optional, tag = "9")]
    pub complete_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Nested message and enum types in `Answer`.
pub mod answer {
    /// Citation info for a segment.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Citation {
        /// Index indicates the start of the segment, measured in bytes (UTF-8
        /// unicode).
        #[prost(int64, tag = "1")]
        pub start_index: i64,
        /// End of the attributed segment, exclusive.
        #[prost(int64, tag = "2")]
        pub end_index: i64,
        /// Citation sources for the attributed segment.
        #[prost(message, repeated, tag = "3")]
        pub sources: ::prost::alloc::vec::Vec<CitationSource>,
    }
    /// Citation source.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct CitationSource {
        /// ID of the citation source.
        #[prost(string, tag = "1")]
        pub reference_id: ::prost::alloc::string::String,
    }
    /// Reference.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Reference {
        /// Search result content.
        #[prost(oneof = "reference::Content", tags = "1, 2, 3")]
        pub content: ::core::option::Option<reference::Content>,
    }
    /// Nested message and enum types in `Reference`.
    pub mod reference {
        /// Unstructured document information.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct UnstructuredDocumentInfo {
            /// Document resource name.
            #[prost(string, tag = "1")]
            pub document: ::prost::alloc::string::String,
            /// URI for the document.
            #[prost(string, tag = "2")]
            pub uri: ::prost::alloc::string::String,
            /// Title.
            #[prost(string, tag = "3")]
            pub title: ::prost::alloc::string::String,
            /// List of cited chunk contents derived from document content.
            #[prost(message, repeated, tag = "4")]
            pub chunk_contents: ::prost::alloc::vec::Vec<
                unstructured_document_info::ChunkContent,
            >,
            /// The structured JSON metadata for the document.
            /// It is populated from the struct data from the Chunk in search result.
            #[prost(message, optional, tag = "5")]
            pub struct_data: ::core::option::Option<::prost_types::Struct>,
        }
        /// Nested message and enum types in `UnstructuredDocumentInfo`.
        pub mod unstructured_document_info {
            /// Chunk content.
            #[derive(Clone, PartialEq, ::prost::Message)]
            pub struct ChunkContent {
                /// Chunk textual content.
                #[prost(string, tag = "1")]
                pub content: ::prost::alloc::string::String,
                /// Page identifier.
                #[prost(string, tag = "2")]
                pub page_identifier: ::prost::alloc::string::String,
                /// The relevance of the chunk for a given query. Values range from 0.0
                /// (completely irrelevant) to 1.0 (completely relevant).
                /// This value is for informational purpose only. It may change for
                /// the same query and chunk at any time due to a model retraining or
                /// change in implementation.
                #[prost(float, optional, tag = "3")]
                pub relevance_score: ::core::option::Option<f32>,
            }
        }
        /// Chunk information.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct ChunkInfo {
            /// Chunk resource name.
            #[prost(string, tag = "1")]
            pub chunk: ::prost::alloc::string::String,
            /// Chunk textual content.
            #[prost(string, tag = "2")]
            pub content: ::prost::alloc::string::String,
            /// The relevance of the chunk for a given query. Values range from 0.0
            /// (completely irrelevant) to 1.0 (completely relevant).
            /// This value is for informational purpose only. It may change for
            /// the same query and chunk at any time due to a model retraining or
            /// change in implementation.
            #[prost(float, optional, tag = "3")]
            pub relevance_score: ::core::option::Option<f32>,
            /// Document metadata.
            #[prost(message, optional, tag = "4")]
            pub document_metadata: ::core::option::Option<chunk_info::DocumentMetadata>,
        }
        /// Nested message and enum types in `ChunkInfo`.
        pub mod chunk_info {
            /// Document metadata.
            #[derive(Clone, PartialEq, ::prost::Message)]
            pub struct DocumentMetadata {
                /// Document resource name.
                #[prost(string, tag = "1")]
                pub document: ::prost::alloc::string::String,
                /// URI for the document.
                #[prost(string, tag = "2")]
                pub uri: ::prost::alloc::string::String,
                /// Title.
                #[prost(string, tag = "3")]
                pub title: ::prost::alloc::string::String,
                /// Page identifier.
                #[prost(string, tag = "4")]
                pub page_identifier: ::prost::alloc::string::String,
                /// The structured JSON metadata for the document.
                /// It is populated from the struct data from the Chunk in search result.
                #[prost(message, optional, tag = "5")]
                pub struct_data: ::core::option::Option<::prost_types::Struct>,
            }
        }
        /// Structured search information.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct StructuredDocumentInfo {
            /// Document resource name.
            #[prost(string, tag = "1")]
            pub document: ::prost::alloc::string::String,
            /// Structured search data.
            #[prost(message, optional, tag = "2")]
            pub struct_data: ::core::option::Option<::prost_types::Struct>,
        }
        /// Search result content.
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum Content {
            /// Unstructured document information.
            #[prost(message, tag = "1")]
            UnstructuredDocumentInfo(UnstructuredDocumentInfo),
            /// Chunk information.
            #[prost(message, tag = "2")]
            ChunkInfo(ChunkInfo),
            /// Structured document information.
            #[prost(message, tag = "3")]
            StructuredDocumentInfo(StructuredDocumentInfo),
        }
    }
    /// Step information.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Step {
        /// The state of the step.
        #[prost(enumeration = "step::State", tag = "1")]
        pub state: i32,
        /// The description of the step.
        #[prost(string, tag = "2")]
        pub description: ::prost::alloc::string::String,
        /// The thought of the step.
        #[prost(string, tag = "3")]
        pub thought: ::prost::alloc::string::String,
        /// Actions.
        #[prost(message, repeated, tag = "4")]
        pub actions: ::prost::alloc::vec::Vec<step::Action>,
    }
    /// Nested message and enum types in `Step`.
    pub mod step {
        /// Action.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct Action {
            /// Observation.
            #[prost(message, optional, tag = "3")]
            pub observation: ::core::option::Option<action::Observation>,
            /// The action.
            #[prost(oneof = "action::Action", tags = "2")]
            pub action: ::core::option::Option<action::Action>,
        }
        /// Nested message and enum types in `Action`.
        pub mod action {
            /// Search action.
            #[derive(Clone, PartialEq, ::prost::Message)]
            pub struct SearchAction {
                /// The query to search.
                #[prost(string, tag = "1")]
                pub query: ::prost::alloc::string::String,
            }
            /// Observation.
            #[derive(Clone, PartialEq, ::prost::Message)]
            pub struct Observation {
                /// Search results observed by the search action, it can be snippets info
                /// or chunk info, depending on the citation type set by the user.
                #[prost(message, repeated, tag = "2")]
                pub search_results: ::prost::alloc::vec::Vec<observation::SearchResult>,
            }
            /// Nested message and enum types in `Observation`.
            pub mod observation {
                #[derive(Clone, PartialEq, ::prost::Message)]
                pub struct SearchResult {
                    /// Document resource name.
                    #[prost(string, tag = "1")]
                    pub document: ::prost::alloc::string::String,
                    /// URI for the document.
                    #[prost(string, tag = "2")]
                    pub uri: ::prost::alloc::string::String,
                    /// Title.
                    #[prost(string, tag = "3")]
                    pub title: ::prost::alloc::string::String,
                    /// If citation_type is DOCUMENT_LEVEL_CITATION, populate document
                    /// level snippets.
                    #[prost(message, repeated, tag = "4")]
                    pub snippet_info: ::prost::alloc::vec::Vec<
                        search_result::SnippetInfo,
                    >,
                    /// If citation_type is CHUNK_LEVEL_CITATION and chunk mode is on,
                    /// populate chunk info.
                    #[prost(message, repeated, tag = "5")]
                    pub chunk_info: ::prost::alloc::vec::Vec<search_result::ChunkInfo>,
                    /// Data representation.
                    /// The structured JSON data for the document.
                    /// It's populated from the struct data from the Document
                    /// , or the Chunk in
                    /// search result
                    /// .
                    #[prost(message, optional, tag = "6")]
                    pub struct_data: ::core::option::Option<::prost_types::Struct>,
                }
                /// Nested message and enum types in `SearchResult`.
                pub mod search_result {
                    /// Snippet information.
                    #[derive(Clone, PartialEq, ::prost::Message)]
                    pub struct SnippetInfo {
                        /// Snippet content.
                        #[prost(string, tag = "1")]
                        pub snippet: ::prost::alloc::string::String,
                        /// Status of the snippet defined by the search team.
                        #[prost(string, tag = "2")]
                        pub snippet_status: ::prost::alloc::string::String,
                    }
                    /// Chunk information.
                    #[derive(Clone, PartialEq, ::prost::Message)]
                    pub struct ChunkInfo {
                        /// Chunk resource name.
                        #[prost(string, tag = "1")]
                        pub chunk: ::prost::alloc::string::String,
                        /// Chunk textual content.
                        #[prost(string, tag = "2")]
                        pub content: ::prost::alloc::string::String,
                        /// The relevance of the chunk for a given query. Values range from
                        /// 0.0 (completely irrelevant) to 1.0 (completely relevant).
                        /// This value is for informational purpose only. It may change for
                        /// the same query and chunk at any time due to a model retraining or
                        /// change in implementation.
                        #[prost(float, optional, tag = "3")]
                        pub relevance_score: ::core::option::Option<f32>,
                    }
                }
            }
            /// The action.
            #[derive(Clone, PartialEq, ::prost::Oneof)]
            pub enum Action {
                /// Search action.
                #[prost(message, tag = "2")]
                SearchAction(SearchAction),
            }
        }
        /// Enumeration of the state of the step.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum State {
            /// Unknown.
            Unspecified = 0,
            /// Step is currently in progress.
            InProgress = 1,
            /// Step currently failed.
            Failed = 2,
            /// Step has succeeded.
            Succeeded = 3,
        }
        impl State {
            /// 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 {
                    State::Unspecified => "STATE_UNSPECIFIED",
                    State::InProgress => "IN_PROGRESS",
                    State::Failed => "FAILED",
                    State::Succeeded => "SUCCEEDED",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "STATE_UNSPECIFIED" => Some(Self::Unspecified),
                    "IN_PROGRESS" => Some(Self::InProgress),
                    "FAILED" => Some(Self::Failed),
                    "SUCCEEDED" => Some(Self::Succeeded),
                    _ => None,
                }
            }
        }
    }
    /// Query understanding information.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct QueryUnderstandingInfo {
        /// Query classification information.
        #[prost(message, repeated, tag = "1")]
        pub query_classification_info: ::prost::alloc::vec::Vec<
            query_understanding_info::QueryClassificationInfo,
        >,
    }
    /// Nested message and enum types in `QueryUnderstandingInfo`.
    pub mod query_understanding_info {
        /// Query classification information.
        #[derive(Clone, Copy, PartialEq, ::prost::Message)]
        pub struct QueryClassificationInfo {
            /// Query classification type.
            #[prost(enumeration = "query_classification_info::Type", tag = "1")]
            pub r#type: i32,
            /// Classification output.
            #[prost(bool, tag = "2")]
            pub positive: bool,
        }
        /// Nested message and enum types in `QueryClassificationInfo`.
        pub mod query_classification_info {
            /// Query classification types.
            #[derive(
                Clone,
                Copy,
                Debug,
                PartialEq,
                Eq,
                Hash,
                PartialOrd,
                Ord,
                ::prost::Enumeration
            )]
            #[repr(i32)]
            pub enum Type {
                /// Unspecified query classification type.
                Unspecified = 0,
                /// Adversarial query classification type.
                AdversarialQuery = 1,
                /// Non-answer-seeking query classification type.
                NonAnswerSeekingQuery = 2,
                /// Jail-breaking query classification type.
                JailBreakingQuery = 3,
            }
            impl Type {
                /// 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 {
                        Type::Unspecified => "TYPE_UNSPECIFIED",
                        Type::AdversarialQuery => "ADVERSARIAL_QUERY",
                        Type::NonAnswerSeekingQuery => "NON_ANSWER_SEEKING_QUERY",
                        Type::JailBreakingQuery => "JAIL_BREAKING_QUERY",
                    }
                }
                /// Creates an enum from field names used in the ProtoBuf definition.
                pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                    match value {
                        "TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                        "ADVERSARIAL_QUERY" => Some(Self::AdversarialQuery),
                        "NON_ANSWER_SEEKING_QUERY" => Some(Self::NonAnswerSeekingQuery),
                        "JAIL_BREAKING_QUERY" => Some(Self::JailBreakingQuery),
                        _ => None,
                    }
                }
            }
        }
    }
    /// Enumeration of the state of the answer generation.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        /// Unknown.
        Unspecified = 0,
        /// Answer generation is currently in progress.
        InProgress = 1,
        /// Answer generation currently failed.
        Failed = 2,
        /// Answer generation has succeeded.
        Succeeded = 3,
    }
    impl State {
        /// 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 {
                State::Unspecified => "STATE_UNSPECIFIED",
                State::InProgress => "IN_PROGRESS",
                State::Failed => "FAILED",
                State::Succeeded => "SUCCEEDED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATE_UNSPECIFIED" => Some(Self::Unspecified),
                "IN_PROGRESS" => Some(Self::InProgress),
                "FAILED" => Some(Self::Failed),
                "SUCCEEDED" => Some(Self::Succeeded),
                _ => None,
            }
        }
    }
    /// An enum for answer skipped reasons.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum AnswerSkippedReason {
        /// Default value. The answer skipped reason is not specified.
        Unspecified = 0,
        /// The adversarial query ignored case.
        AdversarialQueryIgnored = 1,
        /// The non-answer seeking query ignored case.
        NonAnswerSeekingQueryIgnored = 2,
        /// The out-of-domain query ignored case.
        ///
        /// Google skips the answer if there are no high-relevance search results.
        OutOfDomainQueryIgnored = 3,
        /// The potential policy violation case.
        ///
        /// Google skips the answer if there is a potential policy violation
        /// detected. This includes content that may be violent or toxic.
        PotentialPolicyViolation = 4,
        /// The no relevant content case.
        ///
        /// Google skips the answer if there is no relevant content in the
        /// retrieved search results.
        NoRelevantContent = 5,
        /// The jail-breaking query ignored case.
        ///
        /// For example, "Reply in the tone of a competing company's CEO".
        /// Google skips the answer if the query is classified as a jail-breaking
        /// query.
        JailBreakingQueryIgnored = 6,
        /// The customer policy violation case.
        ///
        /// Google skips the summary if there is a customer policy violation
        /// detected. The policy is defined by the customer.
        CustomerPolicyViolation = 7,
    }
    impl AnswerSkippedReason {
        /// 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 {
                AnswerSkippedReason::Unspecified => "ANSWER_SKIPPED_REASON_UNSPECIFIED",
                AnswerSkippedReason::AdversarialQueryIgnored => {
                    "ADVERSARIAL_QUERY_IGNORED"
                }
                AnswerSkippedReason::NonAnswerSeekingQueryIgnored => {
                    "NON_ANSWER_SEEKING_QUERY_IGNORED"
                }
                AnswerSkippedReason::OutOfDomainQueryIgnored => {
                    "OUT_OF_DOMAIN_QUERY_IGNORED"
                }
                AnswerSkippedReason::PotentialPolicyViolation => {
                    "POTENTIAL_POLICY_VIOLATION"
                }
                AnswerSkippedReason::NoRelevantContent => "NO_RELEVANT_CONTENT",
                AnswerSkippedReason::JailBreakingQueryIgnored => {
                    "JAIL_BREAKING_QUERY_IGNORED"
                }
                AnswerSkippedReason::CustomerPolicyViolation => {
                    "CUSTOMER_POLICY_VIOLATION"
                }
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "ANSWER_SKIPPED_REASON_UNSPECIFIED" => Some(Self::Unspecified),
                "ADVERSARIAL_QUERY_IGNORED" => Some(Self::AdversarialQueryIgnored),
                "NON_ANSWER_SEEKING_QUERY_IGNORED" => {
                    Some(Self::NonAnswerSeekingQueryIgnored)
                }
                "OUT_OF_DOMAIN_QUERY_IGNORED" => Some(Self::OutOfDomainQueryIgnored),
                "POTENTIAL_POLICY_VIOLATION" => Some(Self::PotentialPolicyViolation),
                "NO_RELEVANT_CONTENT" => Some(Self::NoRelevantContent),
                "JAIL_BREAKING_QUERY_IGNORED" => Some(Self::JailBreakingQueryIgnored),
                "CUSTOMER_POLICY_VIOLATION" => Some(Self::CustomerPolicyViolation),
                _ => None,
            }
        }
    }
}
/// A singleton resource of
/// [DataStore][google.cloud.discoveryengine.v1alpha.DataStore]. It's empty when
/// [DataStore][google.cloud.discoveryengine.v1alpha.DataStore] is created, which
/// defaults to digital parser. The first call to
/// [DataStoreService.UpdateDocumentProcessingConfig][google.cloud.discoveryengine.v1alpha.DataStoreService.UpdateDocumentProcessingConfig]
/// method will initialize the config.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DocumentProcessingConfig {
    /// The full resource name of the Document Processing Config.
    /// Format:
    /// `projects/*/locations/*/collections/*/dataStores/*/documentProcessingConfig`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Whether chunking mode is enabled.
    #[prost(message, optional, tag = "3")]
    pub chunking_config: ::core::option::Option<
        document_processing_config::ChunkingConfig,
    >,
    /// Configurations for default Document parser.
    /// If not specified, we will configure it as default DigitalParsingConfig, and
    /// the default parsing config will be applied to all file types for Document
    /// parsing.
    #[prost(message, optional, tag = "4")]
    pub default_parsing_config: ::core::option::Option<
        document_processing_config::ParsingConfig,
    >,
    /// Map from file type to override the default parsing configuration based on
    /// the file type. Supported keys:
    ///
    /// * `pdf`: Override parsing config for PDF files, either digital parsing, ocr
    /// parsing or layout parsing is supported.
    /// * `html`: Override parsing config for HTML files, only digital parsing and
    /// layout parsing are supported.
    /// * `docx`: Override parsing config for DOCX files, only digital parsing and
    /// layout parsing are supported.
    /// * `pptx`: Override parsing config for PPTX files, only digital parsing and
    /// layout parsing are supported.
    /// * `xlsx`: Override parsing config for XLSX files, only digital parsing and
    /// layout parsing are supported.
    #[prost(btree_map = "string, message", tag = "5")]
    pub parsing_config_overrides: ::prost::alloc::collections::BTreeMap<
        ::prost::alloc::string::String,
        document_processing_config::ParsingConfig,
    >,
}
/// Nested message and enum types in `DocumentProcessingConfig`.
pub mod document_processing_config {
    /// Configuration for chunking config.
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct ChunkingConfig {
        /// Additional configs that defines the behavior of the chunking.
        #[prost(oneof = "chunking_config::ChunkMode", tags = "1")]
        pub chunk_mode: ::core::option::Option<chunking_config::ChunkMode>,
    }
    /// Nested message and enum types in `ChunkingConfig`.
    pub mod chunking_config {
        /// Configuration for the layout based chunking.
        #[derive(Clone, Copy, PartialEq, ::prost::Message)]
        pub struct LayoutBasedChunkingConfig {
            /// The token size limit for each chunk.
            ///
            /// Supported values: 100-500 (inclusive).
            /// Default value: 500.
            #[prost(int32, tag = "1")]
            pub chunk_size: i32,
            /// Whether to include appending different levels of headings to chunks
            /// from the middle of the document to prevent context loss.
            ///
            /// Default value: False.
            #[prost(bool, tag = "2")]
            pub include_ancestor_headings: bool,
        }
        /// Additional configs that defines the behavior of the chunking.
        #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
        pub enum ChunkMode {
            /// Configuration for the layout based chunking.
            #[prost(message, tag = "1")]
            LayoutBasedChunkingConfig(LayoutBasedChunkingConfig),
        }
    }
    /// Related configurations applied to a specific type of document parser.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ParsingConfig {
        /// Configs for document processing types.
        #[prost(oneof = "parsing_config::TypeDedicatedConfig", tags = "1, 2, 3")]
        pub type_dedicated_config: ::core::option::Option<
            parsing_config::TypeDedicatedConfig,
        >,
    }
    /// Nested message and enum types in `ParsingConfig`.
    pub mod parsing_config {
        /// The digital parsing configurations for documents.
        #[derive(Clone, Copy, PartialEq, ::prost::Message)]
        pub struct DigitalParsingConfig {}
        /// The OCR parsing configurations for documents.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct OcrParsingConfig {
            /// \[DEPRECATED\] This field is deprecated. To use the additional enhanced
            /// document elements processing, please switch to `layout_parsing_config`.
            #[deprecated]
            #[prost(string, repeated, tag = "1")]
            pub enhanced_document_elements: ::prost::alloc::vec::Vec<
                ::prost::alloc::string::String,
            >,
            /// If true, will use native text instead of OCR text on pages containing
            /// native text.
            #[prost(bool, tag = "2")]
            pub use_native_text: bool,
        }
        /// The layout parsing configurations for documents.
        #[derive(Clone, Copy, PartialEq, ::prost::Message)]
        pub struct LayoutParsingConfig {}
        /// Configs for document processing types.
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum TypeDedicatedConfig {
            /// Configurations applied to digital parser.
            #[prost(message, tag = "1")]
            DigitalParsingConfig(DigitalParsingConfig),
            /// Configurations applied to OCR parser. Currently it only applies to
            /// PDFs.
            #[prost(message, tag = "2")]
            OcrParsingConfig(OcrParsingConfig),
            /// Configurations applied to layout parser.
            #[prost(message, tag = "3")]
            LayoutParsingConfig(LayoutParsingConfig),
        }
    }
}
/// Defines the structure and layout of a type of document data.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Schema {
    /// Immutable. The full resource name of the schema, in the format of
    /// `projects/{project}/locations/{location}/collections/{collection}/dataStores/{data_store}/schemas/{schema}`.
    ///
    /// This field must be a UTF-8 encoded string with a length limit of 1024
    /// characters.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. Configurations for fields of the schema.
    #[prost(message, repeated, tag = "4")]
    pub field_configs: ::prost::alloc::vec::Vec<FieldConfig>,
    /// Schema representation. One of
    /// [struct_schema][google.cloud.discoveryengine.v1alpha.Schema.struct_schema]
    /// or [json_schema][google.cloud.discoveryengine.v1alpha.Schema.json_schema]
    /// should be provided otherwise an `INVALID_ARGUMENT` error is thrown.
    #[prost(oneof = "schema::Schema", tags = "2, 3")]
    pub schema: ::core::option::Option<schema::Schema>,
}
/// Nested message and enum types in `Schema`.
pub mod schema {
    /// Schema representation. One of
    /// [struct_schema][google.cloud.discoveryengine.v1alpha.Schema.struct_schema]
    /// or [json_schema][google.cloud.discoveryengine.v1alpha.Schema.json_schema]
    /// should be provided otherwise an `INVALID_ARGUMENT` error is thrown.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Schema {
        /// The structured representation of the schema.
        #[prost(message, tag = "2")]
        StructSchema(::prost_types::Struct),
        /// The JSON representation of the schema.
        #[prost(string, tag = "3")]
        JsonSchema(::prost::alloc::string::String),
    }
}
/// Configurations for fields of a schema. For example, configuring a field is
/// indexable, or searchable.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FieldConfig {
    /// Required. Field path of the schema field.
    /// For example: `title`, `description`, `release_info.release_year`.
    #[prost(string, tag = "1")]
    pub field_path: ::prost::alloc::string::String,
    /// Output only. Raw type of the field.
    #[prost(enumeration = "field_config::FieldType", tag = "2")]
    pub field_type: i32,
    /// If
    /// [indexable_option][google.cloud.discoveryengine.v1alpha.FieldConfig.indexable_option]
    /// is
    /// [INDEXABLE_ENABLED][google.cloud.discoveryengine.v1alpha.FieldConfig.IndexableOption.INDEXABLE_ENABLED],
    /// field values are indexed so that it can be filtered or faceted in
    /// [SearchService.Search][google.cloud.discoveryengine.v1alpha.SearchService.Search].
    ///
    /// If
    /// [indexable_option][google.cloud.discoveryengine.v1alpha.FieldConfig.indexable_option]
    /// is unset, the server behavior defaults to
    /// [INDEXABLE_DISABLED][google.cloud.discoveryengine.v1alpha.FieldConfig.IndexableOption.INDEXABLE_DISABLED]
    /// for fields that support setting indexable options. For those fields that do
    /// not support setting indexable options, such as `object` and `boolean` and
    /// key properties, the server will skip
    /// [indexable_option][google.cloud.discoveryengine.v1alpha.FieldConfig.indexable_option]
    /// setting, and setting
    /// [indexable_option][google.cloud.discoveryengine.v1alpha.FieldConfig.indexable_option]
    /// for those fields will throw `INVALID_ARGUMENT` error.
    #[prost(enumeration = "field_config::IndexableOption", tag = "3")]
    pub indexable_option: i32,
    /// If
    /// [dynamic_facetable_option][google.cloud.discoveryengine.v1alpha.FieldConfig.dynamic_facetable_option]
    /// is
    /// [DYNAMIC_FACETABLE_ENABLED][google.cloud.discoveryengine.v1alpha.FieldConfig.DynamicFacetableOption.DYNAMIC_FACETABLE_ENABLED],
    /// field values are available for dynamic facet. Could only be
    /// [DYNAMIC_FACETABLE_DISABLED][google.cloud.discoveryengine.v1alpha.FieldConfig.DynamicFacetableOption.DYNAMIC_FACETABLE_DISABLED]
    /// if
    /// [FieldConfig.indexable_option][google.cloud.discoveryengine.v1alpha.FieldConfig.indexable_option]
    /// is
    /// [INDEXABLE_DISABLED][google.cloud.discoveryengine.v1alpha.FieldConfig.IndexableOption.INDEXABLE_DISABLED].
    /// Otherwise, an `INVALID_ARGUMENT` error will be returned.
    ///
    /// If
    /// [dynamic_facetable_option][google.cloud.discoveryengine.v1alpha.FieldConfig.dynamic_facetable_option]
    /// is unset, the server behavior defaults to
    /// [DYNAMIC_FACETABLE_DISABLED][google.cloud.discoveryengine.v1alpha.FieldConfig.DynamicFacetableOption.DYNAMIC_FACETABLE_DISABLED]
    /// for fields that support setting dynamic facetable options. For those fields
    /// that do not support setting dynamic facetable options, such as `object` and
    /// `boolean`, the server will skip dynamic facetable option setting, and
    /// setting
    /// [dynamic_facetable_option][google.cloud.discoveryengine.v1alpha.FieldConfig.dynamic_facetable_option]
    /// for those fields will throw `INVALID_ARGUMENT` error.
    #[prost(enumeration = "field_config::DynamicFacetableOption", tag = "4")]
    pub dynamic_facetable_option: i32,
    /// If
    /// [searchable_option][google.cloud.discoveryengine.v1alpha.FieldConfig.searchable_option]
    /// is
    /// [SEARCHABLE_ENABLED][google.cloud.discoveryengine.v1alpha.FieldConfig.SearchableOption.SEARCHABLE_ENABLED],
    /// field values are searchable by text queries in
    /// [SearchService.Search][google.cloud.discoveryengine.v1alpha.SearchService.Search].
    ///
    /// If
    /// [SEARCHABLE_ENABLED][google.cloud.discoveryengine.v1alpha.FieldConfig.SearchableOption.SEARCHABLE_ENABLED]
    /// but field type is numerical, field values will not be searchable by text
    /// queries in
    /// [SearchService.Search][google.cloud.discoveryengine.v1alpha.SearchService.Search],
    /// as there are no text values associated to numerical fields.
    ///
    /// If
    /// [searchable_option][google.cloud.discoveryengine.v1alpha.FieldConfig.searchable_option]
    /// is unset, the server behavior defaults to
    /// [SEARCHABLE_DISABLED][google.cloud.discoveryengine.v1alpha.FieldConfig.SearchableOption.SEARCHABLE_DISABLED]
    /// for fields that support setting searchable options. Only `string` fields
    /// that have no key property mapping support setting
    /// [searchable_option][google.cloud.discoveryengine.v1alpha.FieldConfig.searchable_option].
    ///
    /// For those fields that do not support setting searchable options, the server
    /// will skip searchable option setting, and setting
    /// [searchable_option][google.cloud.discoveryengine.v1alpha.FieldConfig.searchable_option]
    /// for those fields will throw `INVALID_ARGUMENT` error.
    #[prost(enumeration = "field_config::SearchableOption", tag = "5")]
    pub searchable_option: i32,
    /// If
    /// [retrievable_option][google.cloud.discoveryengine.v1alpha.FieldConfig.retrievable_option]
    /// is
    /// [RETRIEVABLE_ENABLED][google.cloud.discoveryengine.v1alpha.FieldConfig.RetrievableOption.RETRIEVABLE_ENABLED],
    /// field values are included in the search results.
    ///
    /// If
    /// [retrievable_option][google.cloud.discoveryengine.v1alpha.FieldConfig.retrievable_option]
    /// is unset, the server behavior defaults to
    /// [RETRIEVABLE_DISABLED][google.cloud.discoveryengine.v1alpha.FieldConfig.RetrievableOption.RETRIEVABLE_DISABLED]
    /// for fields that support setting retrievable options. For those fields
    /// that do not support setting retrievable options, such as `object` and
    /// `boolean`, the server will skip retrievable option setting, and setting
    /// [retrievable_option][google.cloud.discoveryengine.v1alpha.FieldConfig.retrievable_option]
    /// for those fields will throw `INVALID_ARGUMENT` error.
    #[prost(enumeration = "field_config::RetrievableOption", tag = "6")]
    pub retrievable_option: i32,
    /// If
    /// [completable_option][google.cloud.discoveryengine.v1alpha.FieldConfig.completable_option]
    /// is
    /// [COMPLETABLE_ENABLED][google.cloud.discoveryengine.v1alpha.FieldConfig.CompletableOption.COMPLETABLE_ENABLED],
    /// field values are directly used and returned as suggestions for Autocomplete
    /// in
    /// [CompletionService.CompleteQuery][google.cloud.discoveryengine.v1alpha.CompletionService.CompleteQuery].
    ///
    /// If
    /// [completable_option][google.cloud.discoveryengine.v1alpha.FieldConfig.completable_option]
    /// is unset, the server behavior defaults to
    /// [COMPLETABLE_DISABLED][google.cloud.discoveryengine.v1alpha.FieldConfig.CompletableOption.COMPLETABLE_DISABLED]
    /// for fields that support setting completable options, which are just
    /// `string` fields. For those fields that do not support setting completable
    /// options, the server will skip completable option setting, and setting
    /// [completable_option][google.cloud.discoveryengine.v1alpha.FieldConfig.completable_option]
    /// for those fields will throw `INVALID_ARGUMENT` error.
    #[prost(enumeration = "field_config::CompletableOption", tag = "8")]
    pub completable_option: i32,
    /// If
    /// [recs_filterable_option][google.cloud.discoveryengine.v1alpha.FieldConfig.recs_filterable_option]
    /// is
    /// [FILTERABLE_ENABLED][google.cloud.discoveryengine.v1alpha.FieldConfig.FilterableOption.FILTERABLE_ENABLED],
    /// field values are filterable by filter expression in
    /// [RecommendationService.Recommend][google.cloud.discoveryengine.v1alpha.RecommendationService.Recommend].
    ///
    /// If
    /// [FILTERABLE_ENABLED][google.cloud.discoveryengine.v1alpha.FieldConfig.FilterableOption.FILTERABLE_ENABLED]
    /// but the field type is numerical, field values are not filterable by text
    /// queries in
    /// [RecommendationService.Recommend][google.cloud.discoveryengine.v1alpha.RecommendationService.Recommend].
    /// Only textual fields are supported.
    ///
    /// If
    /// [recs_filterable_option][google.cloud.discoveryengine.v1alpha.FieldConfig.recs_filterable_option]
    /// is unset, the default setting is
    /// [FILTERABLE_DISABLED][google.cloud.discoveryengine.v1alpha.FieldConfig.FilterableOption.FILTERABLE_DISABLED]
    /// for fields that support setting filterable options.
    ///
    /// When a field set to \[FILTERABLE_DISABLED\] is filtered, a warning is
    /// generated and an empty result is returned.
    #[prost(enumeration = "field_config::FilterableOption", tag = "9")]
    pub recs_filterable_option: i32,
    /// Output only. Type of the key property that this field is mapped to. Empty
    /// string if this is not annotated as mapped to a key property.
    ///
    /// Example types are `title`, `description`. Full list is defined
    /// by `keyPropertyMapping` in the schema field annotation.
    ///
    /// If the schema field has a `KeyPropertyMapping` annotation,
    /// `indexable_option` and `searchable_option` of this field cannot be
    /// modified.
    #[prost(string, tag = "7")]
    pub key_property_type: ::prost::alloc::string::String,
    /// If this field is set, only the corresponding source will be indexed for
    /// this field. Otherwise, the values from different sources are merged.
    ///
    /// Assuming a page with `<author, a>` in meta tag, and `<author, b>` in page
    /// map:
    ///   if this enum is set to METATAGS, we will only index `<author, a>`;
    ///   if this enum is not set, we will merge them and index `<author, \[a, b\]>`.
    #[prost(
        enumeration = "field_config::AdvancedSiteSearchDataSource",
        repeated,
        tag = "10"
    )]
    pub advanced_site_search_data_sources: ::prost::alloc::vec::Vec<i32>,
    /// Field paths for indexing custom attribute from schema.org data. More
    /// details of schema.org and its defined types can be found at
    /// [schema.org](<https://schema.org>).
    ///
    /// It is only used on advanced site search schema.
    ///
    /// Currently only support full path from root. The full path to a field is
    /// constructed by concatenating field names, starting from `_root`, with
    /// a period `.` as the delimiter. Examples:
    ///
    /// * Publish date of the root: _root.datePublished
    /// * Publish date of the reviews: _root.review.datePublished
    #[prost(string, repeated, tag = "11")]
    pub schema_org_paths: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Nested message and enum types in `FieldConfig`.
pub mod field_config {
    /// Field value type in the Schema.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum FieldType {
        /// Field type is unspecified.
        Unspecified = 0,
        /// Field value type is Object.
        Object = 1,
        /// Field value type is String.
        String = 2,
        /// Field value type is Number.
        Number = 3,
        /// Field value type is Integer.
        Integer = 4,
        /// Field value type is Boolean.
        Boolean = 5,
        /// Field value type is Geolocation. Geolocation is expressed as an object
        /// with the following keys:
        ///
        /// * `id`: a string representing the location id
        /// * `longitude`: a number representing the longitude coordinate of the
        /// location
        /// * `latitude`: a number repesenting the latitude coordinate of the
        /// location
        /// * `address`: a string representing the full address of the location
        ///
        /// `latitude` and `longitude` must always be provided together. At least one
        /// of a) `address` or b) `latitude`-`longitude` pair must be provided.
        Geolocation = 6,
        /// Field value type is Datetime. Datetime can be expressed as either:
        ///
        /// * a number representing milliseconds-since-the-epoch
        /// * a string representing milliseconds-since-the-epoch. e.g.
        /// `"1420070400001"`
        /// * a string representing the [ISO
        /// 8601](<https://en.wikipedia.org/wiki/ISO_8601>) date or date and time. e.g.
        /// `"2015-01-01"` or `"2015-01-01T12:10:30Z"`
        Datetime = 7,
    }
    impl FieldType {
        /// 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 {
                FieldType::Unspecified => "FIELD_TYPE_UNSPECIFIED",
                FieldType::Object => "OBJECT",
                FieldType::String => "STRING",
                FieldType::Number => "NUMBER",
                FieldType::Integer => "INTEGER",
                FieldType::Boolean => "BOOLEAN",
                FieldType::Geolocation => "GEOLOCATION",
                FieldType::Datetime => "DATETIME",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "FIELD_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "OBJECT" => Some(Self::Object),
                "STRING" => Some(Self::String),
                "NUMBER" => Some(Self::Number),
                "INTEGER" => Some(Self::Integer),
                "BOOLEAN" => Some(Self::Boolean),
                "GEOLOCATION" => Some(Self::Geolocation),
                "DATETIME" => Some(Self::Datetime),
                _ => None,
            }
        }
    }
    /// The setting of Indexable options in schema.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum IndexableOption {
        /// Value used when unset.
        Unspecified = 0,
        /// Indexable option enabled for a schema field.
        IndexableEnabled = 1,
        /// Indexable option disabled for a schema field.
        IndexableDisabled = 2,
    }
    impl IndexableOption {
        /// 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 {
                IndexableOption::Unspecified => "INDEXABLE_OPTION_UNSPECIFIED",
                IndexableOption::IndexableEnabled => "INDEXABLE_ENABLED",
                IndexableOption::IndexableDisabled => "INDEXABLE_DISABLED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "INDEXABLE_OPTION_UNSPECIFIED" => Some(Self::Unspecified),
                "INDEXABLE_ENABLED" => Some(Self::IndexableEnabled),
                "INDEXABLE_DISABLED" => Some(Self::IndexableDisabled),
                _ => None,
            }
        }
    }
    /// The status of the dynamic facetable option of a schema field.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum DynamicFacetableOption {
        /// Value used when unset.
        Unspecified = 0,
        /// Dynamic facetable option enabled for a schema field.
        DynamicFacetableEnabled = 1,
        /// Dynamic facetable option disabled for a schema field.
        DynamicFacetableDisabled = 2,
    }
    impl DynamicFacetableOption {
        /// 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 {
                DynamicFacetableOption::Unspecified => {
                    "DYNAMIC_FACETABLE_OPTION_UNSPECIFIED"
                }
                DynamicFacetableOption::DynamicFacetableEnabled => {
                    "DYNAMIC_FACETABLE_ENABLED"
                }
                DynamicFacetableOption::DynamicFacetableDisabled => {
                    "DYNAMIC_FACETABLE_DISABLED"
                }
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "DYNAMIC_FACETABLE_OPTION_UNSPECIFIED" => Some(Self::Unspecified),
                "DYNAMIC_FACETABLE_ENABLED" => Some(Self::DynamicFacetableEnabled),
                "DYNAMIC_FACETABLE_DISABLED" => Some(Self::DynamicFacetableDisabled),
                _ => None,
            }
        }
    }
    /// The setting of Searchable options in schema.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum SearchableOption {
        /// Value used when unset.
        Unspecified = 0,
        /// Searchable option enabled for a schema field.
        SearchableEnabled = 1,
        /// Searchable option disabled for a schema field.
        SearchableDisabled = 2,
    }
    impl SearchableOption {
        /// 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 {
                SearchableOption::Unspecified => "SEARCHABLE_OPTION_UNSPECIFIED",
                SearchableOption::SearchableEnabled => "SEARCHABLE_ENABLED",
                SearchableOption::SearchableDisabled => "SEARCHABLE_DISABLED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "SEARCHABLE_OPTION_UNSPECIFIED" => Some(Self::Unspecified),
                "SEARCHABLE_ENABLED" => Some(Self::SearchableEnabled),
                "SEARCHABLE_DISABLED" => Some(Self::SearchableDisabled),
                _ => None,
            }
        }
    }
    /// The setting of Retrievable options in schema.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum RetrievableOption {
        /// Value used when unset.
        Unspecified = 0,
        /// Retrievable option enabled for a schema field.
        RetrievableEnabled = 1,
        /// Retrievable option disabled for a schema field.
        RetrievableDisabled = 2,
    }
    impl RetrievableOption {
        /// 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 {
                RetrievableOption::Unspecified => "RETRIEVABLE_OPTION_UNSPECIFIED",
                RetrievableOption::RetrievableEnabled => "RETRIEVABLE_ENABLED",
                RetrievableOption::RetrievableDisabled => "RETRIEVABLE_DISABLED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "RETRIEVABLE_OPTION_UNSPECIFIED" => Some(Self::Unspecified),
                "RETRIEVABLE_ENABLED" => Some(Self::RetrievableEnabled),
                "RETRIEVABLE_DISABLED" => Some(Self::RetrievableDisabled),
                _ => None,
            }
        }
    }
    /// The setting of Completable options in schema.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum CompletableOption {
        /// Value used when unset.
        Unspecified = 0,
        /// Completable option enabled for a schema field.
        CompletableEnabled = 1,
        /// Completable option disabled for a schema field.
        CompletableDisabled = 2,
    }
    impl CompletableOption {
        /// 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 {
                CompletableOption::Unspecified => "COMPLETABLE_OPTION_UNSPECIFIED",
                CompletableOption::CompletableEnabled => "COMPLETABLE_ENABLED",
                CompletableOption::CompletableDisabled => "COMPLETABLE_DISABLED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "COMPLETABLE_OPTION_UNSPECIFIED" => Some(Self::Unspecified),
                "COMPLETABLE_ENABLED" => Some(Self::CompletableEnabled),
                "COMPLETABLE_DISABLED" => Some(Self::CompletableDisabled),
                _ => None,
            }
        }
    }
    /// Sets the filterable option for schema fields.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum FilterableOption {
        /// Value used when unset.
        Unspecified = 0,
        /// Filterable option enabled for a schema field.
        FilterableEnabled = 1,
        /// Filterable option disabled for a schema field.
        FilterableDisabled = 2,
    }
    impl FilterableOption {
        /// 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 {
                FilterableOption::Unspecified => "FILTERABLE_OPTION_UNSPECIFIED",
                FilterableOption::FilterableEnabled => "FILTERABLE_ENABLED",
                FilterableOption::FilterableDisabled => "FILTERABLE_DISABLED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "FILTERABLE_OPTION_UNSPECIFIED" => Some(Self::Unspecified),
                "FILTERABLE_ENABLED" => Some(Self::FilterableEnabled),
                "FILTERABLE_DISABLED" => Some(Self::FilterableDisabled),
                _ => None,
            }
        }
    }
    /// Optional source of the advanced site search field.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum AdvancedSiteSearchDataSource {
        /// Value used when unset.
        Unspecified = 0,
        /// Retrieve value from meta tag.
        Metatags = 1,
        /// Retrieve value from page map.
        Pagemap = 2,
        /// Retrieve value from the attributes set by
        /// [SiteSearchEngineService.SetUriPatternDocumentData][google.cloud.discoveryengine.v1alpha.SiteSearchEngineService.SetUriPatternDocumentData]
        /// API.
        UriPatternMapping = 3,
        /// Retrieve value from schema.org data.
        SchemaOrg = 4,
    }
    impl AdvancedSiteSearchDataSource {
        /// 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 {
                AdvancedSiteSearchDataSource::Unspecified => {
                    "ADVANCED_SITE_SEARCH_DATA_SOURCE_UNSPECIFIED"
                }
                AdvancedSiteSearchDataSource::Metatags => "METATAGS",
                AdvancedSiteSearchDataSource::Pagemap => "PAGEMAP",
                AdvancedSiteSearchDataSource::UriPatternMapping => "URI_PATTERN_MAPPING",
                AdvancedSiteSearchDataSource::SchemaOrg => "SCHEMA_ORG",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "ADVANCED_SITE_SEARCH_DATA_SOURCE_UNSPECIFIED" => Some(Self::Unspecified),
                "METATAGS" => Some(Self::Metatags),
                "PAGEMAP" => Some(Self::Pagemap),
                "URI_PATTERN_MAPPING" => Some(Self::UriPatternMapping),
                "SCHEMA_ORG" => Some(Self::SchemaOrg),
                _ => None,
            }
        }
    }
}
/// DataStore captures global settings and configs at the DataStore level.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DataStore {
    /// Immutable. The full resource name of the data store.
    /// Format:
    /// `projects/{project}/locations/{location}/collections/{collection_id}/dataStores/{data_store_id}`.
    ///
    /// This field must be a UTF-8 encoded string with a length limit of 1024
    /// characters.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. The data store display name.
    ///
    /// This field must be a UTF-8 encoded string with a length limit of 128
    /// characters. Otherwise, an INVALID_ARGUMENT error is returned.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// Immutable. The industry vertical that the data store registers.
    #[prost(enumeration = "IndustryVertical", tag = "3")]
    pub industry_vertical: i32,
    /// The solutions that the data store enrolls. Available solutions for each
    /// [industry_vertical][google.cloud.discoveryengine.v1alpha.DataStore.industry_vertical]:
    ///
    /// * `MEDIA`: `SOLUTION_TYPE_RECOMMENDATION` and `SOLUTION_TYPE_SEARCH`.
    /// * `SITE_SEARCH`: `SOLUTION_TYPE_SEARCH` is automatically enrolled. Other
    ///    solutions cannot be enrolled.
    #[prost(enumeration = "SolutionType", repeated, tag = "5")]
    pub solution_types: ::prost::alloc::vec::Vec<i32>,
    /// Output only. The id of the default
    /// [Schema][google.cloud.discoveryengine.v1alpha.Schema] asscociated to this
    /// data store.
    #[prost(string, tag = "7")]
    pub default_schema_id: ::prost::alloc::string::String,
    /// Immutable. The content config of the data store. If this field is unset,
    /// the server behavior defaults to
    /// [ContentConfig.NO_CONTENT][google.cloud.discoveryengine.v1alpha.DataStore.ContentConfig.NO_CONTENT].
    #[prost(enumeration = "data_store::ContentConfig", tag = "6")]
    pub content_config: i32,
    /// Output only. Timestamp the
    /// [DataStore][google.cloud.discoveryengine.v1alpha.DataStore] was created at.
    #[prost(message, optional, tag = "4")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Language info for DataStore.
    #[prost(message, optional, tag = "14")]
    pub language_info: ::core::option::Option<LanguageInfo>,
    /// Output only. Data store level identity provider config.
    #[prost(message, optional, tag = "21")]
    pub idp_config: ::core::option::Option<IdpConfig>,
    /// Immutable. Whether data in the
    /// [DataStore][google.cloud.discoveryengine.v1alpha.DataStore] has ACL
    /// information. If set to `true`, the source data must have ACL. ACL will be
    /// ingested when data is ingested by
    /// [DocumentService.ImportDocuments][google.cloud.discoveryengine.v1alpha.DocumentService.ImportDocuments]
    /// methods.
    ///
    /// When ACL is enabled for the
    /// [DataStore][google.cloud.discoveryengine.v1alpha.DataStore],
    /// [Document][google.cloud.discoveryengine.v1alpha.Document] can't be accessed
    /// by calling
    /// [DocumentService.GetDocument][google.cloud.discoveryengine.v1alpha.DocumentService.GetDocument]
    /// or
    /// [DocumentService.ListDocuments][google.cloud.discoveryengine.v1alpha.DocumentService.ListDocuments].
    ///
    /// Currently ACL is only supported in `GENERIC` industry vertical with
    /// non-`PUBLIC_WEBSITE` content config.
    #[prost(bool, tag = "24")]
    pub acl_enabled: bool,
    /// Config to store data store type configuration for workspace data. This
    /// must be set when
    /// [DataStore.content_config][google.cloud.discoveryengine.v1alpha.DataStore.content_config]
    /// is set as
    /// [DataStore.ContentConfig.GOOGLE_WORKSPACE][google.cloud.discoveryengine.v1alpha.DataStore.ContentConfig.GOOGLE_WORKSPACE].
    #[prost(message, optional, tag = "25")]
    pub workspace_config: ::core::option::Option<WorkspaceConfig>,
    /// Configuration for Document understanding and enrichment.
    #[prost(message, optional, tag = "27")]
    pub document_processing_config: ::core::option::Option<DocumentProcessingConfig>,
    /// The start schema to use for this
    /// [DataStore][google.cloud.discoveryengine.v1alpha.DataStore] when
    /// provisioning it. If unset, a default vertical specialized schema will be
    /// used.
    ///
    /// This field is only used by [CreateDataStore][] API, and will be ignored if
    /// used in other APIs. This field will be omitted from all API responses
    /// including [CreateDataStore][] API. To retrieve a schema of a
    /// [DataStore][google.cloud.discoveryengine.v1alpha.DataStore], use
    /// [SchemaService.GetSchema][google.cloud.discoveryengine.v1alpha.SchemaService.GetSchema]
    /// API instead.
    ///
    /// The provided schema will be validated against certain rules on schema.
    /// Learn more from [this
    /// doc](<https://cloud.google.com/generative-ai-app-builder/docs/provide-schema>).
    #[prost(message, optional, tag = "28")]
    pub starting_schema: ::core::option::Option<Schema>,
}
/// Nested message and enum types in `DataStore`.
pub mod data_store {
    /// Content config of the data store.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ContentConfig {
        /// Default value.
        Unspecified = 0,
        /// Only contains documents without any
        /// [Document.content][google.cloud.discoveryengine.v1alpha.Document.content].
        NoContent = 1,
        /// Only contains documents with
        /// [Document.content][google.cloud.discoveryengine.v1alpha.Document.content].
        ContentRequired = 2,
        /// The data store is used for public website search.
        PublicWebsite = 3,
        /// The data store is used for workspace search. Details of workspace
        /// data store are specified in the
        /// [WorkspaceConfig][google.cloud.discoveryengine.v1alpha.WorkspaceConfig].
        GoogleWorkspace = 4,
    }
    impl ContentConfig {
        /// 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 {
                ContentConfig::Unspecified => "CONTENT_CONFIG_UNSPECIFIED",
                ContentConfig::NoContent => "NO_CONTENT",
                ContentConfig::ContentRequired => "CONTENT_REQUIRED",
                ContentConfig::PublicWebsite => "PUBLIC_WEBSITE",
                ContentConfig::GoogleWorkspace => "GOOGLE_WORKSPACE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "CONTENT_CONFIG_UNSPECIFIED" => Some(Self::Unspecified),
                "NO_CONTENT" => Some(Self::NoContent),
                "CONTENT_REQUIRED" => Some(Self::ContentRequired),
                "PUBLIC_WEBSITE" => Some(Self::PublicWebsite),
                "GOOGLE_WORKSPACE" => Some(Self::GoogleWorkspace),
                _ => None,
            }
        }
    }
}
/// Language info for DataStore.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LanguageInfo {
    /// The language code for the DataStore.
    #[prost(string, tag = "1")]
    pub language_code: ::prost::alloc::string::String,
    /// Output only. This is the normalized form of language_code.
    /// E.g.: language_code of `en-GB`, `en_GB`, `en-UK` or `en-gb`
    /// will have normalized_language_code of `en-GB`.
    #[prost(string, tag = "2")]
    pub normalized_language_code: ::prost::alloc::string::String,
    /// Output only. Language part of normalized_language_code.
    /// E.g.: `en-US` -> `en`, `zh-Hans-HK` -> `zh`, `en` -> `en`.
    #[prost(string, tag = "3")]
    pub language: ::prost::alloc::string::String,
    /// Output only. Region part of normalized_language_code, if present.
    /// E.g.: `en-US` -> `US`, `zh-Hans-HK` -> `HK`, `en` -> ``.
    #[prost(string, tag = "4")]
    pub region: ::prost::alloc::string::String,
}
/// Config to store data store type configuration for workspace data
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WorkspaceConfig {
    /// The Google Workspace data source.
    #[prost(enumeration = "workspace_config::Type", tag = "1")]
    pub r#type: i32,
    /// Obfuscated Dasher customer ID.
    #[prost(string, tag = "2")]
    pub dasher_customer_id: ::prost::alloc::string::String,
}
/// Nested message and enum types in `WorkspaceConfig`.
pub mod workspace_config {
    /// Specifies the type of Workspace App supported by this DataStore
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Type {
        /// Defaults to an unspecified Workspace type.
        Unspecified = 0,
        /// Workspace Data Store contains Drive data
        GoogleDrive = 1,
        /// Workspace Data Store contains Mail data
        GoogleMail = 2,
        /// Workspace Data Store contains Sites data
        GoogleSites = 3,
        /// Workspace Data Store contains Calendar data
        GoogleCalendar = 4,
        /// Workspace Data Store contains Chat data
        GoogleChat = 5,
        /// Workspace Data Store contains Groups data
        GoogleGroups = 6,
        /// Workspace Data Store contains Keep data
        GoogleKeep = 7,
    }
    impl Type {
        /// 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 {
                Type::Unspecified => "TYPE_UNSPECIFIED",
                Type::GoogleDrive => "GOOGLE_DRIVE",
                Type::GoogleMail => "GOOGLE_MAIL",
                Type::GoogleSites => "GOOGLE_SITES",
                Type::GoogleCalendar => "GOOGLE_CALENDAR",
                Type::GoogleChat => "GOOGLE_CHAT",
                Type::GoogleGroups => "GOOGLE_GROUPS",
                Type::GoogleKeep => "GOOGLE_KEEP",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "GOOGLE_DRIVE" => Some(Self::GoogleDrive),
                "GOOGLE_MAIL" => Some(Self::GoogleMail),
                "GOOGLE_SITES" => Some(Self::GoogleSites),
                "GOOGLE_CALENDAR" => Some(Self::GoogleCalendar),
                "GOOGLE_CHAT" => Some(Self::GoogleChat),
                "GOOGLE_GROUPS" => Some(Self::GoogleGroups),
                "GOOGLE_KEEP" => Some(Self::GoogleKeep),
                _ => None,
            }
        }
    }
}
/// Request message for
/// [SchemaService.GetSchema][google.cloud.discoveryengine.v1alpha.SchemaService.GetSchema]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetSchemaRequest {
    /// Required. The full resource name of the schema, in the format of
    /// `projects/{project}/locations/{location}/collections/{collection}/dataStores/{data_store}/schemas/{schema}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for
/// [SchemaService.ListSchemas][google.cloud.discoveryengine.v1alpha.SchemaService.ListSchemas]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListSchemasRequest {
    /// Required. The parent data store resource name, in the format of
    /// `projects/{project}/locations/{location}/collections/{collection}/dataStores/{data_store}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The maximum number of
    /// [Schema][google.cloud.discoveryengine.v1alpha.Schema]s to return. The
    /// service may return fewer than this value.
    ///
    /// If unspecified, at most 100
    /// [Schema][google.cloud.discoveryengine.v1alpha.Schema]s are returned.
    ///
    /// The maximum value is 1000; values above 1000 are set to 1000.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// A page token, received from a previous
    /// [SchemaService.ListSchemas][google.cloud.discoveryengine.v1alpha.SchemaService.ListSchemas]
    /// call. Provide this to retrieve the subsequent page.
    ///
    /// When paginating, all other parameters provided to
    /// [SchemaService.ListSchemas][google.cloud.discoveryengine.v1alpha.SchemaService.ListSchemas]
    /// must match the call that provided the page token.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// Response message for
/// [SchemaService.ListSchemas][google.cloud.discoveryengine.v1alpha.SchemaService.ListSchemas]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListSchemasResponse {
    /// The [Schema][google.cloud.discoveryengine.v1alpha.Schema]s.
    #[prost(message, repeated, tag = "1")]
    pub schemas: ::prost::alloc::vec::Vec<Schema>,
    /// A token that can be sent as
    /// [ListSchemasRequest.page_token][google.cloud.discoveryengine.v1alpha.ListSchemasRequest.page_token]
    /// to retrieve the next page. If this field is omitted, there are no
    /// subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for
/// [SchemaService.CreateSchema][google.cloud.discoveryengine.v1alpha.SchemaService.CreateSchema]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateSchemaRequest {
    /// Required. The parent data store resource name, in the format of
    /// `projects/{project}/locations/{location}/collections/{collection}/dataStores/{data_store}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The [Schema][google.cloud.discoveryengine.v1alpha.Schema] to
    /// create.
    #[prost(message, optional, tag = "2")]
    pub schema: ::core::option::Option<Schema>,
    /// Required. The ID to use for the
    /// [Schema][google.cloud.discoveryengine.v1alpha.Schema], which becomes the
    /// final component of the
    /// [Schema.name][google.cloud.discoveryengine.v1alpha.Schema.name].
    ///
    /// This field should conform to
    /// [RFC-1034](<https://tools.ietf.org/html/rfc1034>) standard with a length
    /// limit of 63 characters.
    #[prost(string, tag = "3")]
    pub schema_id: ::prost::alloc::string::String,
}
/// Request message for
/// [SchemaService.UpdateSchema][google.cloud.discoveryengine.v1alpha.SchemaService.UpdateSchema]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateSchemaRequest {
    /// Required. The [Schema][google.cloud.discoveryengine.v1alpha.Schema] to
    /// update.
    #[prost(message, optional, tag = "1")]
    pub schema: ::core::option::Option<Schema>,
    /// If set to true, and the
    /// [Schema][google.cloud.discoveryengine.v1alpha.Schema] is not found, a new
    /// [Schema][google.cloud.discoveryengine.v1alpha.Schema] is created. In this
    /// situation, `update_mask` is ignored.
    #[prost(bool, tag = "3")]
    pub allow_missing: bool,
}
/// Request message for
/// [SchemaService.DeleteSchema][google.cloud.discoveryengine.v1alpha.SchemaService.DeleteSchema]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteSchemaRequest {
    /// Required. The full resource name of the schema, in the format of
    /// `projects/{project}/locations/{location}/collections/{collection}/dataStores/{data_store}/schemas/{schema}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Metadata for Create Schema LRO.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct CreateSchemaMetadata {
    /// Operation create time.
    #[prost(message, optional, tag = "1")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Operation last update time. If the operation is done, this is also the
    /// finish time.
    #[prost(message, optional, tag = "2")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Metadata for UpdateSchema LRO.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct UpdateSchemaMetadata {
    /// Operation create time.
    #[prost(message, optional, tag = "1")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Operation last update time. If the operation is done, this is also the
    /// finish time.
    #[prost(message, optional, tag = "2")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Metadata for DeleteSchema LRO.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct DeleteSchemaMetadata {
    /// Operation create time.
    #[prost(message, optional, tag = "1")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Operation last update time. If the operation is done, this is also the
    /// finish time.
    #[prost(message, optional, tag = "2")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Generated client implementations.
pub mod schema_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for managing [Schema][google.cloud.discoveryengine.v1alpha.Schema]s.
    #[derive(Debug, Clone)]
    pub struct SchemaServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl<T> SchemaServiceClient<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,
        ) -> SchemaServiceClient<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,
        {
            SchemaServiceClient::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
        }
        /// Gets a [Schema][google.cloud.discoveryengine.v1alpha.Schema].
        pub async fn get_schema(
            &mut self,
            request: impl tonic::IntoRequest<super::GetSchemaRequest>,
        ) -> std::result::Result<tonic::Response<super::Schema>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.SchemaService/GetSchema",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.SchemaService",
                        "GetSchema",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets a list of [Schema][google.cloud.discoveryengine.v1alpha.Schema]s.
        pub async fn list_schemas(
            &mut self,
            request: impl tonic::IntoRequest<super::ListSchemasRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListSchemasResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.SchemaService/ListSchemas",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.SchemaService",
                        "ListSchemas",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a [Schema][google.cloud.discoveryengine.v1alpha.Schema].
        pub async fn create_schema(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateSchemaRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.SchemaService/CreateSchema",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.SchemaService",
                        "CreateSchema",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates a [Schema][google.cloud.discoveryengine.v1alpha.Schema].
        pub async fn update_schema(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateSchemaRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.SchemaService/UpdateSchema",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.SchemaService",
                        "UpdateSchema",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes a [Schema][google.cloud.discoveryengine.v1alpha.Schema].
        pub async fn delete_schema(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteSchemaRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.SchemaService/DeleteSchema",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.SchemaService",
                        "DeleteSchema",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Request for
/// [DataStoreService.CreateDataStore][google.cloud.discoveryengine.v1alpha.DataStoreService.CreateDataStore]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateDataStoreRequest {
    /// Required. The parent resource name, such as
    /// `projects/{project}/locations/{location}/collections/{collection}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The [DataStore][google.cloud.discoveryengine.v1alpha.DataStore]
    /// to create.
    #[prost(message, optional, tag = "2")]
    pub data_store: ::core::option::Option<DataStore>,
    /// Required. The ID to use for the
    /// [DataStore][google.cloud.discoveryengine.v1alpha.DataStore], which will
    /// become the final component of the
    /// [DataStore][google.cloud.discoveryengine.v1alpha.DataStore]'s resource
    /// name.
    ///
    /// This field must conform to [RFC-1034](<https://tools.ietf.org/html/rfc1034>)
    /// standard with a length limit of 63 characters. Otherwise, an
    /// INVALID_ARGUMENT error is returned.
    #[prost(string, tag = "3")]
    pub data_store_id: ::prost::alloc::string::String,
    /// A boolean flag indicating whether user want to directly create an advanced
    /// data store for site search.
    /// If the data store is not configured as site
    /// search (GENERIC vertical and PUBLIC_WEBSITE content_config), this flag will
    /// be ignored.
    #[prost(bool, tag = "4")]
    pub create_advanced_site_search: bool,
    /// A boolean flag indicating whether to skip the default schema creation for
    /// the data store. Only enable this flag if you are certain that the default
    /// schema is incompatible with your use case.
    ///
    /// If set to true, you must manually create a schema for the data store before
    /// any documents can be ingested.
    ///
    /// This flag cannot be specified if `data_store.starting_schema` is specified.
    #[prost(bool, tag = "7")]
    pub skip_default_schema_creation: bool,
}
/// Request message for
/// [DataStoreService.GetDataStore][google.cloud.discoveryengine.v1alpha.DataStoreService.GetDataStore]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetDataStoreRequest {
    /// Required. Full resource name of
    /// [DataStore][google.cloud.discoveryengine.v1alpha.DataStore], such as
    /// `projects/{project}/locations/{location}/collections/{collection_id}/dataStores/{data_store_id}`.
    ///
    /// If the caller does not have permission to access the
    /// [DataStore][google.cloud.discoveryengine.v1alpha.DataStore], regardless of
    /// whether or not it exists, a PERMISSION_DENIED error is returned.
    ///
    /// If the requested
    /// [DataStore][google.cloud.discoveryengine.v1alpha.DataStore] does not exist,
    /// a NOT_FOUND error is returned.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Metadata related to the progress of the
/// [DataStoreService.CreateDataStore][google.cloud.discoveryengine.v1alpha.DataStoreService.CreateDataStore]
/// operation. This will be returned by the google.longrunning.Operation.metadata
/// field.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct CreateDataStoreMetadata {
    /// Operation create time.
    #[prost(message, optional, tag = "1")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Operation last update time. If the operation is done, this is also the
    /// finish time.
    #[prost(message, optional, tag = "2")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Request message for
/// [DataStoreService.ListDataStores][google.cloud.discoveryengine.v1alpha.DataStoreService.ListDataStores]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListDataStoresRequest {
    /// Required. The parent branch resource name, such as
    /// `projects/{project}/locations/{location}/collections/{collection_id}`.
    ///
    /// If the caller does not have permission to list
    /// [DataStore][google.cloud.discoveryengine.v1alpha.DataStore]s under this
    /// location, regardless of whether or not this data store exists, a
    /// PERMISSION_DENIED error is returned.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Maximum number of
    /// [DataStore][google.cloud.discoveryengine.v1alpha.DataStore]s to return. If
    /// unspecified, defaults to 10. The maximum allowed value is 50. Values above
    /// 50 will be coerced to 50.
    ///
    /// If this field is negative, an INVALID_ARGUMENT is returned.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// A page token
    /// [ListDataStoresResponse.next_page_token][google.cloud.discoveryengine.v1alpha.ListDataStoresResponse.next_page_token],
    /// received from a previous
    /// [DataStoreService.ListDataStores][google.cloud.discoveryengine.v1alpha.DataStoreService.ListDataStores]
    /// call. Provide this to retrieve the subsequent page.
    ///
    /// When paginating, all other parameters provided to
    /// [DataStoreService.ListDataStores][google.cloud.discoveryengine.v1alpha.DataStoreService.ListDataStores]
    /// must match the call that provided the page token. Otherwise, an
    /// INVALID_ARGUMENT error is returned.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Filter by solution type .
    /// For example: `filter = 'solution_type:SOLUTION_TYPE_SEARCH'`
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
}
/// Response message for
/// [DataStoreService.ListDataStores][google.cloud.discoveryengine.v1alpha.DataStoreService.ListDataStores]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListDataStoresResponse {
    /// All the customer's
    /// [DataStore][google.cloud.discoveryengine.v1alpha.DataStore]s.
    #[prost(message, repeated, tag = "1")]
    pub data_stores: ::prost::alloc::vec::Vec<DataStore>,
    /// A token that can be sent as
    /// [ListDataStoresRequest.page_token][google.cloud.discoveryengine.v1alpha.ListDataStoresRequest.page_token]
    /// to retrieve the next page. If this field is omitted, there are no
    /// subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for
/// [DataStoreService.DeleteDataStore][google.cloud.discoveryengine.v1alpha.DataStoreService.DeleteDataStore]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteDataStoreRequest {
    /// Required. Full resource name of
    /// [DataStore][google.cloud.discoveryengine.v1alpha.DataStore], such as
    /// `projects/{project}/locations/{location}/collections/{collection_id}/dataStores/{data_store_id}`.
    ///
    /// If the caller does not have permission to delete the
    /// [DataStore][google.cloud.discoveryengine.v1alpha.DataStore], regardless of
    /// whether or not it exists, a PERMISSION_DENIED error is returned.
    ///
    /// If the [DataStore][google.cloud.discoveryengine.v1alpha.DataStore] to
    /// delete does not exist, a NOT_FOUND error is returned.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for
/// [DataStoreService.UpdateDataStore][google.cloud.discoveryengine.v1alpha.DataStoreService.UpdateDataStore]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateDataStoreRequest {
    /// Required. The [DataStore][google.cloud.discoveryengine.v1alpha.DataStore]
    /// to update.
    ///
    /// If the caller does not have permission to update the
    /// [DataStore][google.cloud.discoveryengine.v1alpha.DataStore], regardless of
    /// whether or not it exists, a PERMISSION_DENIED error is returned.
    ///
    /// If the [DataStore][google.cloud.discoveryengine.v1alpha.DataStore] to
    /// update does not exist, a NOT_FOUND error is returned.
    #[prost(message, optional, tag = "1")]
    pub data_store: ::core::option::Option<DataStore>,
    /// Indicates which fields in the provided
    /// [DataStore][google.cloud.discoveryengine.v1alpha.DataStore] to update.
    ///
    /// If an unsupported or unknown field is provided, an INVALID_ARGUMENT error
    /// is returned.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Metadata related to the progress of the
/// [DataStoreService.DeleteDataStore][google.cloud.discoveryengine.v1alpha.DataStoreService.DeleteDataStore]
/// operation. This will be returned by the google.longrunning.Operation.metadata
/// field.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct DeleteDataStoreMetadata {
    /// Operation create time.
    #[prost(message, optional, tag = "1")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Operation last update time. If the operation is done, this is also the
    /// finish time.
    #[prost(message, optional, tag = "2")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Request for
/// [DataStoreService.GetDocumentProcessingConfig][google.cloud.discoveryengine.v1alpha.DataStoreService.GetDocumentProcessingConfig]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetDocumentProcessingConfigRequest {
    /// Required. Full DocumentProcessingConfig resource name. Format:
    /// `projects/{project_number}/locations/{location_id}/collections/{collection_id}/dataStores/{data_store_id}/documentProcessingConfig`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request for
/// [DataStoreService.UpdateDocumentProcessingConfig][google.cloud.discoveryengine.v1alpha.DataStoreService.UpdateDocumentProcessingConfig]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateDocumentProcessingConfigRequest {
    /// Required. The
    /// [DocumentProcessingConfig][google.cloud.discoveryengine.v1alpha.DocumentProcessingConfig]
    /// to update.
    ///
    /// If the caller does not have permission to update the
    /// [DocumentProcessingConfig][google.cloud.discoveryengine.v1alpha.DocumentProcessingConfig],
    /// then a PERMISSION_DENIED error is returned.
    ///
    /// If the
    /// [DocumentProcessingConfig][google.cloud.discoveryengine.v1alpha.DocumentProcessingConfig]
    /// to update does not exist, a NOT_FOUND error is returned.
    #[prost(message, optional, tag = "1")]
    pub document_processing_config: ::core::option::Option<DocumentProcessingConfig>,
    /// Indicates which fields in the provided
    /// [DocumentProcessingConfig][google.cloud.discoveryengine.v1alpha.DocumentProcessingConfig]
    /// to update. The following are the only supported fields:
    ///
    /// * [DocumentProcessingConfig.ocr_config][google.cloud.discoveryengine.v1alpha.DocumentProcessingConfig.ocr_config]
    ///
    /// If not set, all supported fields are updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Generated client implementations.
pub mod data_store_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for managing
    /// [DataStore][google.cloud.discoveryengine.v1alpha.DataStore] configuration.
    #[derive(Debug, Clone)]
    pub struct DataStoreServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl<T> DataStoreServiceClient<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,
        ) -> DataStoreServiceClient<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,
        {
            DataStoreServiceClient::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
        }
        /// Creates a [DataStore][google.cloud.discoveryengine.v1alpha.DataStore].
        ///
        /// DataStore is for storing
        /// [Documents][google.cloud.discoveryengine.v1alpha.Document]. To serve these
        /// documents for Search, or Recommendation use case, an
        /// [Engine][google.cloud.discoveryengine.v1alpha.Engine] needs to be created
        /// separately.
        pub async fn create_data_store(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateDataStoreRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.DataStoreService/CreateDataStore",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.DataStoreService",
                        "CreateDataStore",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets a [DataStore][google.cloud.discoveryengine.v1alpha.DataStore].
        pub async fn get_data_store(
            &mut self,
            request: impl tonic::IntoRequest<super::GetDataStoreRequest>,
        ) -> std::result::Result<tonic::Response<super::DataStore>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.DataStoreService/GetDataStore",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.DataStoreService",
                        "GetDataStore",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists all the [DataStore][google.cloud.discoveryengine.v1alpha.DataStore]s
        /// associated with the project.
        pub async fn list_data_stores(
            &mut self,
            request: impl tonic::IntoRequest<super::ListDataStoresRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListDataStoresResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.DataStoreService/ListDataStores",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.DataStoreService",
                        "ListDataStores",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes a [DataStore][google.cloud.discoveryengine.v1alpha.DataStore].
        pub async fn delete_data_store(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteDataStoreRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.DataStoreService/DeleteDataStore",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.DataStoreService",
                        "DeleteDataStore",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates a [DataStore][google.cloud.discoveryengine.v1alpha.DataStore]
        pub async fn update_data_store(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateDataStoreRequest>,
        ) -> std::result::Result<tonic::Response<super::DataStore>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.DataStoreService/UpdateDataStore",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.DataStoreService",
                        "UpdateDataStore",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets a
        /// [DocumentProcessingConfig][google.cloud.discoveryengine.v1alpha.DocumentProcessingConfig].
        pub async fn get_document_processing_config(
            &mut self,
            request: impl tonic::IntoRequest<super::GetDocumentProcessingConfigRequest>,
        ) -> std::result::Result<
            tonic::Response<super::DocumentProcessingConfig>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.DataStoreService/GetDocumentProcessingConfig",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.DataStoreService",
                        "GetDocumentProcessingConfig",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the
        /// [DocumentProcessingConfig][google.cloud.discoveryengine.v1alpha.DocumentProcessingConfig].
        /// [DocumentProcessingConfig][google.cloud.discoveryengine.v1alpha.DocumentProcessingConfig]
        /// is a singleon resource of
        /// [DataStore][google.cloud.discoveryengine.v1alpha.DataStore]. It's empty
        /// when [DataStore][google.cloud.discoveryengine.v1alpha.DataStore] is
        /// created. The first call to this method will set up
        /// [DocumentProcessingConfig][google.cloud.discoveryengine.v1alpha.DocumentProcessingConfig].
        pub async fn update_document_processing_config(
            &mut self,
            request: impl tonic::IntoRequest<
                super::UpdateDocumentProcessingConfigRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::DocumentProcessingConfig>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.DataStoreService/UpdateDocumentProcessingConfig",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.DataStoreService",
                        "UpdateDocumentProcessingConfig",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Request message for
/// [EstimateBillingService.EstimateDataSize][google.cloud.discoveryengine.v1alpha.EstimateBillingService.EstimateDataSize]
/// method
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EstimateDataSizeRequest {
    /// Required. Full resource name of the location, such as
    /// `projects/{project}/locations/{location}`.
    #[prost(string, tag = "1")]
    pub location: ::prost::alloc::string::String,
    /// Data source for which we are estimating its size.
    #[prost(oneof = "estimate_data_size_request::DataSource", tags = "2, 3")]
    pub data_source: ::core::option::Option<estimate_data_size_request::DataSource>,
}
/// Nested message and enum types in `EstimateDataSizeRequest`.
pub mod estimate_data_size_request {
    /// Data source is a set of website patterns that we crawl to get
    /// the total number of websites.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct WebsiteDataSource {
        /// Required. The URI patterns to estimate the data sizes. At most 10
        /// patterns are allowed, otherwise an INVALID_ARGUMENT error is thrown.
        #[prost(message, repeated, tag = "1")]
        pub estimator_uri_patterns: ::prost::alloc::vec::Vec<
            website_data_source::EstimatorUriPattern,
        >,
    }
    /// Nested message and enum types in `WebsiteDataSource`.
    pub mod website_data_source {
        /// URI patterns that we use to crawl.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct EstimatorUriPattern {
            /// User provided URI pattern. For example, `foo.com/bar/*`.
            #[prost(string, tag = "1")]
            pub provided_uri_pattern: ::prost::alloc::string::String,
            /// Whether we infer the generated URI or use the exact provided one.
            #[prost(bool, tag = "2")]
            pub exact_match: bool,
            /// Whether the pattern is exclusive or not. If set to true, the pattern is
            /// considered exclusive. If unset or set to false, the pattern is
            /// considered inclusive by default.
            #[prost(bool, tag = "3")]
            pub exclusive: bool,
        }
    }
    /// Data source contains files either in Cloud Storage or BigQuery.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct FileDataSource {
        /// Which source contains the files to be used.
        #[prost(oneof = "file_data_source::Source", tags = "1, 2")]
        pub source: ::core::option::Option<file_data_source::Source>,
    }
    /// Nested message and enum types in `FileDataSource`.
    pub mod file_data_source {
        /// Which source contains the files to be used.
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum Source {
            /// Cloud Storage location for the input content.
            #[prost(message, tag = "1")]
            GcsSource(super::super::GcsSource),
            /// BigQuery input source.
            #[prost(message, tag = "2")]
            BigquerySource(super::super::BigQuerySource),
        }
    }
    /// Data source for which we are estimating its size.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum DataSource {
        /// Website data.
        #[prost(message, tag = "2")]
        WebsiteDataSource(WebsiteDataSource),
        /// Structured or unstructured data.
        #[prost(message, tag = "3")]
        FileDataSource(FileDataSource),
    }
}
/// Response of the EstimateDataSize request. If the long running
/// operation was successful, then this message is returned by the
/// google.longrunning.Operations.response field if the operation was successful.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct EstimateDataSizeResponse {
    /// Data size in terms of bytes.
    #[prost(int64, tag = "1")]
    pub data_size_bytes: i64,
    /// Total number of documents.
    #[prost(int64, tag = "2")]
    pub document_count: i64,
}
/// Metadata related to the progress of the EstimateDataSize operation. This is
/// returned by the google.longrunning.Operation.metadata field.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct EstimateDataSizeMetadata {
    /// Operation create time.
    #[prost(message, optional, tag = "1")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Generated client implementations.
pub mod estimate_billing_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for managing billing estimations resources.
    #[derive(Debug, Clone)]
    pub struct EstimateBillingServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl<T> EstimateBillingServiceClient<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,
        ) -> EstimateBillingServiceClient<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,
        {
            EstimateBillingServiceClient::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
        }
        /// Estimates the data size to be used by a customer.
        pub async fn estimate_data_size(
            &mut self,
            request: impl tonic::IntoRequest<super::EstimateDataSizeRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.EstimateBillingService/EstimateDataSize",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.EstimateBillingService",
                        "EstimateDataSize",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// External conversation proto definition.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Conversation {
    /// Immutable. Fully qualified name
    /// `projects/{project}/locations/global/collections/{collection}/dataStore/*/conversations/*`
    /// or
    /// `projects/{project}/locations/global/collections/{collection}/engines/*/conversations/*`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The state of the Conversation.
    #[prost(enumeration = "conversation::State", tag = "2")]
    pub state: i32,
    /// A unique identifier for tracking users.
    #[prost(string, tag = "3")]
    pub user_pseudo_id: ::prost::alloc::string::String,
    /// Conversation messages.
    #[prost(message, repeated, tag = "4")]
    pub messages: ::prost::alloc::vec::Vec<ConversationMessage>,
    /// Output only. The time the conversation started.
    #[prost(message, optional, tag = "5")]
    pub start_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The time the conversation finished.
    #[prost(message, optional, tag = "6")]
    pub end_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Nested message and enum types in `Conversation`.
pub mod conversation {
    /// Enumeration of the state of the conversation.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        /// Unknown.
        Unspecified = 0,
        /// Conversation is currently open.
        InProgress = 1,
        /// Conversation has been completed.
        Completed = 2,
    }
    impl State {
        /// 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 {
                State::Unspecified => "STATE_UNSPECIFIED",
                State::InProgress => "IN_PROGRESS",
                State::Completed => "COMPLETED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATE_UNSPECIFIED" => Some(Self::Unspecified),
                "IN_PROGRESS" => Some(Self::InProgress),
                "COMPLETED" => Some(Self::Completed),
                _ => None,
            }
        }
    }
}
/// Defines a reply message to user.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Reply {
    /// DEPRECATED: use `summary` instead.
    /// Text reply.
    #[deprecated]
    #[prost(string, tag = "1")]
    pub reply: ::prost::alloc::string::String,
    /// References in the reply.
    #[deprecated]
    #[prost(message, repeated, tag = "2")]
    pub references: ::prost::alloc::vec::Vec<reply::Reference>,
    /// Summary based on search results.
    #[prost(message, optional, tag = "3")]
    pub summary: ::core::option::Option<search_response::Summary>,
}
/// Nested message and enum types in `Reply`.
pub mod reply {
    /// Defines reference in reply.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Reference {
        /// URI link reference.
        #[prost(string, tag = "1")]
        pub uri: ::prost::alloc::string::String,
        /// Anchor text.
        #[prost(string, tag = "2")]
        pub anchor_text: ::prost::alloc::string::String,
        /// Anchor text start index.
        #[prost(int32, tag = "3")]
        pub start: i32,
        /// Anchor text end index.
        #[prost(int32, tag = "4")]
        pub end: i32,
    }
}
/// Defines context of the conversation
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ConversationContext {
    /// The current list of documents the user is seeing.
    /// It contains the document resource references.
    #[prost(string, repeated, tag = "1")]
    pub context_documents: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// The current active document the user opened.
    /// It contains the document resource reference.
    #[prost(string, tag = "2")]
    pub active_document: ::prost::alloc::string::String,
}
/// Defines text input.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TextInput {
    /// Text input.
    #[prost(string, tag = "1")]
    pub input: ::prost::alloc::string::String,
    /// Conversation context of the input.
    #[prost(message, optional, tag = "2")]
    pub context: ::core::option::Option<ConversationContext>,
}
/// Defines a conversation message.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ConversationMessage {
    /// Output only. Message creation timestamp.
    #[prost(message, optional, tag = "3")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    #[prost(oneof = "conversation_message::Message", tags = "1, 2")]
    pub message: ::core::option::Option<conversation_message::Message>,
}
/// Nested message and enum types in `ConversationMessage`.
pub mod conversation_message {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Message {
        /// User text input.
        #[prost(message, tag = "1")]
        UserInput(super::TextInput),
        /// Search reply.
        #[prost(message, tag = "2")]
        Reply(super::Reply),
    }
}
/// External session proto definition.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Session {
    /// Immutable. Fully qualified name
    /// `projects/{project}/locations/global/collections/{collection}/engines/{engine}/sessions/*`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The state of the session.
    #[prost(enumeration = "session::State", tag = "2")]
    pub state: i32,
    /// A unique identifier for tracking users.
    #[prost(string, tag = "3")]
    pub user_pseudo_id: ::prost::alloc::string::String,
    /// Turns.
    #[prost(message, repeated, tag = "4")]
    pub turns: ::prost::alloc::vec::Vec<session::Turn>,
    /// Output only. The time the session started.
    #[prost(message, optional, tag = "5")]
    pub start_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The time the session finished.
    #[prost(message, optional, tag = "6")]
    pub end_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Nested message and enum types in `Session`.
pub mod session {
    /// Represents a turn, including a query from the user and a
    /// answer from service.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Turn {
        /// The user query.
        #[prost(message, optional, tag = "1")]
        pub query: ::core::option::Option<super::Query>,
        /// The resource name of the answer to the user query.
        ///
        /// Only set if the answer generation (/answer API call) happened in this
        /// turn.
        #[prost(string, tag = "2")]
        pub answer: ::prost::alloc::string::String,
    }
    /// Enumeration of the state of the session.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        /// State is unspecified.
        Unspecified = 0,
        /// The session is currently open.
        InProgress = 1,
    }
    impl State {
        /// 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 {
                State::Unspecified => "STATE_UNSPECIFIED",
                State::InProgress => "IN_PROGRESS",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATE_UNSPECIFIED" => Some(Self::Unspecified),
                "IN_PROGRESS" => Some(Self::InProgress),
                _ => None,
            }
        }
    }
}
/// Defines a user inputed query.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Query {
    /// Unique Id for the query.
    #[prost(string, tag = "1")]
    pub query_id: ::prost::alloc::string::String,
    /// Query content.
    #[prost(oneof = "query::Content", tags = "2")]
    pub content: ::core::option::Option<query::Content>,
}
/// Nested message and enum types in `Query`.
pub mod query {
    /// Query content.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Content {
        /// Plain text.
        #[prost(string, tag = "2")]
        Text(::prost::alloc::string::String),
    }
}
/// Request message for
/// [ConversationalSearchService.ConverseConversation][google.cloud.discoveryengine.v1alpha.ConversationalSearchService.ConverseConversation]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ConverseConversationRequest {
    /// Required. The resource name of the Conversation to get. Format:
    /// `projects/{project_number}/locations/{location_id}/collections/{collection}/dataStores/{data_store_id}/conversations/{conversation_id}`.
    /// Use
    /// `projects/{project_number}/locations/{location_id}/collections/{collection}/dataStores/{data_store_id}/conversations/-`
    /// to activate auto session mode, which automatically creates a new
    /// conversation inside a ConverseConversation session.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. Current user input.
    #[prost(message, optional, tag = "2")]
    pub query: ::core::option::Option<TextInput>,
    /// The resource name of the Serving Config to use. Format:
    /// `projects/{project_number}/locations/{location_id}/collections/{collection}/dataStores/{data_store_id}/servingConfigs/{serving_config_id}`
    /// If this is not set, the default serving config will be used.
    #[prost(string, tag = "3")]
    pub serving_config: ::prost::alloc::string::String,
    /// The conversation to be used by auto session only. The name field will be
    /// ignored as we automatically assign new name for the conversation in auto
    /// session.
    #[prost(message, optional, tag = "5")]
    pub conversation: ::core::option::Option<Conversation>,
    /// Whether to turn on safe search.
    #[prost(bool, tag = "6")]
    pub safe_search: bool,
    /// The user labels applied to a resource must meet the following requirements:
    ///
    /// * Each resource can have multiple labels, up to a maximum of 64.
    /// * Each label must be a key-value pair.
    /// * Keys have a minimum length of 1 character and a maximum length of 63
    ///    characters and cannot be empty. Values can be empty and have a maximum
    ///    length of 63 characters.
    /// * Keys and values can contain only lowercase letters, numeric characters,
    ///    underscores, and dashes. All characters must use UTF-8 encoding, and
    ///    international characters are allowed.
    /// * The key portion of a label must be unique. However, you can use the same
    ///    key with multiple resources.
    /// * Keys must start with a lowercase letter or international character.
    ///
    /// See [Google Cloud
    /// Document](<https://cloud.google.com/resource-manager/docs/creating-managing-labels#requirements>)
    /// for more details.
    #[prost(btree_map = "string, string", tag = "7")]
    pub user_labels: ::prost::alloc::collections::BTreeMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// A specification for configuring the summary returned in the response.
    #[prost(message, optional, tag = "8")]
    pub summary_spec: ::core::option::Option<
        search_request::content_search_spec::SummarySpec,
    >,
    /// The filter syntax consists of an expression language for constructing a
    /// predicate from one or more fields of the documents being filtered. Filter
    /// expression is case-sensitive. This will be used to filter search results
    /// which may affect the summary response.
    ///
    /// If this field is unrecognizable, an  `INVALID_ARGUMENT`  is returned.
    ///
    /// Filtering in Vertex AI Search is done by mapping the LHS filter key to a
    /// key property defined in the Vertex AI Search backend -- this mapping is
    /// defined by the customer in their schema. For example a media customer might
    /// have a field 'name' in their schema. In this case the filter would look
    /// like this: filter --> name:'ANY("king kong")'
    ///
    /// For more information about filtering including syntax and filter
    /// operators, see
    /// [Filter](<https://cloud.google.com/generative-ai-app-builder/docs/filter-search-metadata>)
    #[prost(string, tag = "9")]
    pub filter: ::prost::alloc::string::String,
    /// Boost specification to boost certain documents in search results which may
    /// affect the converse response. For more information on boosting, see
    /// [Boosting](<https://cloud.google.com/retail/docs/boosting#boost>)
    #[prost(message, optional, tag = "10")]
    pub boost_spec: ::core::option::Option<search_request::BoostSpec>,
}
/// Response message for
/// [ConversationalSearchService.ConverseConversation][google.cloud.discoveryengine.v1alpha.ConversationalSearchService.ConverseConversation]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ConverseConversationResponse {
    /// Answer to the current query.
    #[prost(message, optional, tag = "1")]
    pub reply: ::core::option::Option<Reply>,
    /// Updated conversation including the answer.
    #[prost(message, optional, tag = "2")]
    pub conversation: ::core::option::Option<Conversation>,
    /// Suggested related questions.
    #[prost(string, repeated, tag = "6")]
    pub related_questions: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Search Results.
    #[prost(message, repeated, tag = "3")]
    pub search_results: ::prost::alloc::vec::Vec<search_response::SearchResult>,
}
/// Request for CreateConversation method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateConversationRequest {
    /// Required. Full resource name of parent data store. Format:
    /// `projects/{project_number}/locations/{location_id}/collections/{collection}/dataStores/{data_store_id}`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The conversation to create.
    #[prost(message, optional, tag = "2")]
    pub conversation: ::core::option::Option<Conversation>,
}
/// Request for UpdateConversation method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateConversationRequest {
    /// Required. The Conversation to update.
    #[prost(message, optional, tag = "1")]
    pub conversation: ::core::option::Option<Conversation>,
    /// Indicates which fields in the provided
    /// [Conversation][google.cloud.discoveryengine.v1alpha.Conversation] to
    /// update. The following are NOT supported:
    ///
    /// * [Conversation.name][google.cloud.discoveryengine.v1alpha.Conversation.name]
    ///
    /// If not set or empty, all supported fields are updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request for DeleteConversation method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteConversationRequest {
    /// Required. The resource name of the Conversation to delete. Format:
    /// `projects/{project_number}/locations/{location_id}/collections/{collection}/dataStores/{data_store_id}/conversations/{conversation_id}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request for GetConversation method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetConversationRequest {
    /// Required. The resource name of the Conversation to get. Format:
    /// `projects/{project_number}/locations/{location_id}/collections/{collection}/dataStores/{data_store_id}/conversations/{conversation_id}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request for ListConversations method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListConversationsRequest {
    /// Required. The data store resource name. Format:
    /// `projects/{project_number}/locations/{location_id}/collections/{collection}/dataStores/{data_store_id}`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Maximum number of results to return. If unspecified, defaults
    /// to 50. Max allowed value is 1000.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// A page token, received from a previous `ListConversations` call.
    /// Provide this to retrieve the subsequent page.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// A filter to apply on the list results. The supported features are:
    /// user_pseudo_id, state.
    ///
    /// Example:
    /// "user_pseudo_id = some_id"
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
    /// A comma-separated list of fields to order by, sorted in ascending order.
    /// Use "desc" after a field name for descending.
    /// Supported fields:
    ///    * `update_time`
    ///    * `create_time`
    ///    * `conversation_name`
    ///
    /// Example:
    /// "update_time desc"
    /// "create_time"
    #[prost(string, tag = "5")]
    pub order_by: ::prost::alloc::string::String,
}
/// Response for ListConversations method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListConversationsResponse {
    /// All the Conversations for a given data store.
    #[prost(message, repeated, tag = "1")]
    pub conversations: ::prost::alloc::vec::Vec<Conversation>,
    /// Pagination token, if not returned indicates the last page.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for
/// [ConversationalSearchService.AnswerQuery][google.cloud.discoveryengine.v1alpha.ConversationalSearchService.AnswerQuery]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AnswerQueryRequest {
    /// Required. The resource name of the Search serving config, such as
    /// `projects/*/locations/global/collections/default_collection/engines/*/servingConfigs/default_serving_config`,
    /// or
    /// `projects/*/locations/global/collections/default_collection/dataStores/*/servingConfigs/default_serving_config`.
    /// This field is used to identify the serving configuration name, set
    /// of models used to make the search.
    #[prost(string, tag = "1")]
    pub serving_config: ::prost::alloc::string::String,
    /// Required. Current user query.
    #[prost(message, optional, tag = "2")]
    pub query: ::core::option::Option<Query>,
    /// The session resource name. Not required.
    ///
    /// When session field is not set, the API is in sessionless mode.
    ///
    /// We support auto session mode: users can use the wildcard symbol `-` as
    /// session ID.  A new ID will be automatically generated and assigned.
    #[prost(string, tag = "3")]
    pub session: ::prost::alloc::string::String,
    /// Model specification.
    #[prost(message, optional, tag = "4")]
    pub safety_spec: ::core::option::Option<answer_query_request::SafetySpec>,
    /// Related questions specification.
    #[prost(message, optional, tag = "5")]
    pub related_questions_spec: ::core::option::Option<
        answer_query_request::RelatedQuestionsSpec,
    >,
    /// Answer generation specification.
    #[prost(message, optional, tag = "7")]
    pub answer_generation_spec: ::core::option::Option<
        answer_query_request::AnswerGenerationSpec,
    >,
    /// Search specification.
    #[prost(message, optional, tag = "8")]
    pub search_spec: ::core::option::Option<answer_query_request::SearchSpec>,
    /// Query understanding specification.
    #[prost(message, optional, tag = "9")]
    pub query_understanding_spec: ::core::option::Option<
        answer_query_request::QueryUnderstandingSpec,
    >,
    /// Asynchronous mode control.
    ///
    /// If enabled, the response will be returned with answer/session resource
    /// name without final answer. The API users need to do the polling to get
    /// the latest status of answer/session by calling
    /// [ConversationalSearchService.GetAnswer][google.cloud.discoveryengine.v1alpha.ConversationalSearchService.GetAnswer]
    /// or
    /// [ConversationalSearchService.GetSession][google.cloud.discoveryengine.v1alpha.ConversationalSearchService.GetSession]
    /// method.
    #[prost(bool, tag = "10")]
    pub asynchronous_mode: bool,
    /// A unique identifier for tracking visitors. For example, this could be
    /// implemented with an HTTP cookie, which should be able to uniquely identify
    /// a visitor on a single device. This unique identifier should not change if
    /// the visitor logs in or out of the website.
    ///
    /// This field should NOT have a fixed value such as `unknown_visitor`.
    ///
    /// The field must be a UTF-8 encoded string with a length limit of 128
    /// characters. Otherwise, an  `INVALID_ARGUMENT`  error is returned.
    #[prost(string, tag = "12")]
    pub user_pseudo_id: ::prost::alloc::string::String,
    /// The user labels applied to a resource must meet the following requirements:
    ///
    /// * Each resource can have multiple labels, up to a maximum of 64.
    /// * Each label must be a key-value pair.
    /// * Keys have a minimum length of 1 character and a maximum length of 63
    ///    characters and cannot be empty. Values can be empty and have a maximum
    ///    length of 63 characters.
    /// * Keys and values can contain only lowercase letters, numeric characters,
    ///    underscores, and dashes. All characters must use UTF-8 encoding, and
    ///    international characters are allowed.
    /// * The key portion of a label must be unique. However, you can use the same
    ///    key with multiple resources.
    /// * Keys must start with a lowercase letter or international character.
    ///
    /// See [Google Cloud
    /// Document](<https://cloud.google.com/resource-manager/docs/creating-managing-labels#requirements>)
    /// for more details.
    #[prost(btree_map = "string, string", tag = "13")]
    pub user_labels: ::prost::alloc::collections::BTreeMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
/// Nested message and enum types in `AnswerQueryRequest`.
pub mod answer_query_request {
    /// Safety specification.
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct SafetySpec {
        /// Enable the safety filtering on the answer response. It is false by
        /// default.
        #[prost(bool, tag = "1")]
        pub enable: bool,
    }
    /// Related questions specification.
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct RelatedQuestionsSpec {
        /// Enable related questions feature if true.
        #[prost(bool, tag = "1")]
        pub enable: bool,
    }
    /// Answer generation specification.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct AnswerGenerationSpec {
        /// Answer generation model specification.
        #[prost(message, optional, tag = "1")]
        pub model_spec: ::core::option::Option<answer_generation_spec::ModelSpec>,
        /// Answer generation prompt specification.
        #[prost(message, optional, tag = "2")]
        pub prompt_spec: ::core::option::Option<answer_generation_spec::PromptSpec>,
        /// Specifies whether to include citation metadata in the answer. The default
        /// value is `false`.
        #[prost(bool, tag = "3")]
        pub include_citations: bool,
        /// Language code for Answer. Use language tags defined by
        /// [BCP47](<https://www.rfc-editor.org/rfc/bcp/bcp47.txt>).
        /// Note: This is an experimental feature.
        #[prost(string, tag = "4")]
        pub answer_language_code: ::prost::alloc::string::String,
        /// Specifies whether to filter out adversarial queries. The default value
        /// is `false`.
        ///
        /// Google employs search-query classification to detect adversarial
        /// queries. No answer is returned if the search query is classified as an
        /// adversarial query. For example, a user might ask a question regarding
        /// negative comments about the company or submit a query designed to
        /// generate unsafe, policy-violating output. If this field is set to
        /// `true`, we skip generating answers for adversarial queries and return
        /// fallback messages instead.
        #[prost(bool, tag = "5")]
        pub ignore_adversarial_query: bool,
        /// Specifies whether to filter out queries that are not answer-seeking.
        /// The default value is `false`.
        ///
        /// Google employs search-query classification to detect answer-seeking
        /// queries. No answer is returned if the search query is classified as a
        /// non-answer seeking query. If this field is set to `true`, we skip
        /// generating answers for non-answer seeking queries and return
        /// fallback messages instead.
        #[prost(bool, tag = "6")]
        pub ignore_non_answer_seeking_query: bool,
        /// Specifies whether to filter out queries that have low relevance.
        ///
        /// If this field is set to `false`, all search results are used regardless
        /// of relevance to generate answers. If set to `true` or unset, the behavior
        /// will be determined automatically by the service.
        #[prost(bool, optional, tag = "7")]
        pub ignore_low_relevant_content: ::core::option::Option<bool>,
    }
    /// Nested message and enum types in `AnswerGenerationSpec`.
    pub mod answer_generation_spec {
        /// Answer Generation Model specification.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct ModelSpec {
            /// Model version. If not set, it will use the default stable model.
            /// Allowed values are: stable, preview.
            #[prost(string, tag = "1")]
            pub model_version: ::prost::alloc::string::String,
        }
        /// Answer generation prompt specification.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct PromptSpec {
            /// Customized preamble.
            #[prost(string, tag = "1")]
            pub preamble: ::prost::alloc::string::String,
        }
    }
    /// Search specification.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct SearchSpec {
        /// Search parameters to control the search behavior.
        /// Or provide search result list to generate answer.
        #[prost(oneof = "search_spec::Input", tags = "1, 2")]
        pub input: ::core::option::Option<search_spec::Input>,
    }
    /// Nested message and enum types in `SearchSpec`.
    pub mod search_spec {
        /// Search parameters.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct SearchParams {
            /// Number of search results to return.
            /// The default value is 10.
            #[prost(int32, tag = "1")]
            pub max_return_results: i32,
            /// The filter syntax consists of an expression language for constructing
            /// a predicate from one or more fields of the documents being filtered.
            /// Filter expression is case-sensitive. This will be used to filter
            /// search results which may affect the Answer response.
            ///
            /// If this field is unrecognizable, an  `INVALID_ARGUMENT`  is returned.
            ///
            /// Filtering in Vertex AI Search is done by mapping the LHS filter key
            /// to a key property defined in the Vertex AI Search backend -- this
            /// mapping is defined by the customer in their schema. For example a
            /// media customers might have a field 'name' in their schema. In this
            /// case the filter would look like this: filter --> name:'ANY("king
            /// kong")'
            ///
            /// For more information about filtering including syntax and filter
            /// operators, see
            /// [Filter](<https://cloud.google.com/generative-ai-app-builder/docs/filter-search-metadata>)
            #[prost(string, tag = "2")]
            pub filter: ::prost::alloc::string::String,
            /// Boost specification to boost certain documents in search results which
            /// may affect the answer query response. For more information on boosting,
            /// see [Boosting](<https://cloud.google.com/retail/docs/boosting#boost>)
            #[prost(message, optional, tag = "3")]
            pub boost_spec: ::core::option::Option<
                super::super::search_request::BoostSpec,
            >,
            /// The order in which documents are returned. Documents can be ordered
            /// by a field in an
            /// [Document][google.cloud.discoveryengine.v1alpha.Document] object. Leave
            /// it unset if ordered by relevance. `order_by` expression is
            /// case-sensitive. For more information on ordering, see
            /// [Ordering](<https://cloud.google.com/retail/docs/filter-and-order#order>)
            ///
            /// If this field is unrecognizable, an `INVALID_ARGUMENT` is returned.
            #[prost(string, tag = "4")]
            pub order_by: ::prost::alloc::string::String,
            /// Specifies the search result mode. If unspecified, the
            /// search result mode defaults to `DOCUMENTS`.
            /// See [parse and chunk
            /// documents](<https://cloud.google.com/generative-ai-app-builder/docs/parse-chunk-documents>)
            #[prost(
                enumeration = "super::super::search_request::content_search_spec::SearchResultMode",
                tag = "5"
            )]
            pub search_result_mode: i32,
            /// Custom fine tuning configs.
            #[prost(message, optional, tag = "6")]
            pub custom_fine_tuning_spec: ::core::option::Option<
                super::super::CustomFineTuningSpec,
            >,
            /// Specs defining dataStores to filter on in a search call and
            /// configurations for those dataStores. This is only considered for
            /// engines with multiple dataStores use case. For single dataStore within
            /// an engine, they should use the specs at the top level.
            #[prost(message, repeated, tag = "7")]
            pub data_store_specs: ::prost::alloc::vec::Vec<
                super::super::search_request::DataStoreSpec,
            >,
        }
        /// Search result list.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct SearchResultList {
            /// Search results.
            #[prost(message, repeated, tag = "1")]
            pub search_results: ::prost::alloc::vec::Vec<
                search_result_list::SearchResult,
            >,
        }
        /// Nested message and enum types in `SearchResultList`.
        pub mod search_result_list {
            /// Search result.
            #[derive(Clone, PartialEq, ::prost::Message)]
            pub struct SearchResult {
                /// Search result content.
                #[prost(oneof = "search_result::Content", tags = "1, 2")]
                pub content: ::core::option::Option<search_result::Content>,
            }
            /// Nested message and enum types in `SearchResult`.
            pub mod search_result {
                /// Unstructured document information.
                #[derive(Clone, PartialEq, ::prost::Message)]
                pub struct UnstructuredDocumentInfo {
                    /// Document resource name.
                    #[prost(string, tag = "1")]
                    pub document: ::prost::alloc::string::String,
                    /// URI for the document.
                    #[prost(string, tag = "2")]
                    pub uri: ::prost::alloc::string::String,
                    /// Title.
                    #[prost(string, tag = "3")]
                    pub title: ::prost::alloc::string::String,
                    /// List of document contexts.
                    #[prost(message, repeated, tag = "4")]
                    pub document_contexts: ::prost::alloc::vec::Vec<
                        unstructured_document_info::DocumentContext,
                    >,
                    /// List of extractive segments.
                    #[prost(message, repeated, tag = "5")]
                    pub extractive_segments: ::prost::alloc::vec::Vec<
                        unstructured_document_info::ExtractiveSegment,
                    >,
                    /// List of extractive answers.
                    #[prost(message, repeated, tag = "6")]
                    pub extractive_answers: ::prost::alloc::vec::Vec<
                        unstructured_document_info::ExtractiveAnswer,
                    >,
                }
                /// Nested message and enum types in `UnstructuredDocumentInfo`.
                pub mod unstructured_document_info {
                    /// Document context.
                    #[derive(Clone, PartialEq, ::prost::Message)]
                    pub struct DocumentContext {
                        /// Page identifier.
                        #[prost(string, tag = "1")]
                        pub page_identifier: ::prost::alloc::string::String,
                        /// Document content.
                        #[prost(string, tag = "2")]
                        pub content: ::prost::alloc::string::String,
                    }
                    /// Extractive segment.
                    /// [Guide](<https://cloud.google.com/generative-ai-app-builder/docs/snippets#extractive-segments>)
                    #[derive(Clone, PartialEq, ::prost::Message)]
                    pub struct ExtractiveSegment {
                        /// Page identifier.
                        #[prost(string, tag = "1")]
                        pub page_identifier: ::prost::alloc::string::String,
                        /// Extractive segment content.
                        #[prost(string, tag = "2")]
                        pub content: ::prost::alloc::string::String,
                    }
                    /// Extractive answer.
                    /// [Guide](<https://cloud.google.com/generative-ai-app-builder/docs/snippets#get-answers>)
                    #[derive(Clone, PartialEq, ::prost::Message)]
                    pub struct ExtractiveAnswer {
                        /// Page identifier.
                        #[prost(string, tag = "1")]
                        pub page_identifier: ::prost::alloc::string::String,
                        /// Extractive answer content.
                        #[prost(string, tag = "2")]
                        pub content: ::prost::alloc::string::String,
                    }
                }
                /// Chunk information.
                #[derive(Clone, PartialEq, ::prost::Message)]
                pub struct ChunkInfo {
                    /// Chunk resource name.
                    #[prost(string, tag = "1")]
                    pub chunk: ::prost::alloc::string::String,
                    /// Chunk textual content.
                    #[prost(string, tag = "2")]
                    pub content: ::prost::alloc::string::String,
                }
                /// Search result content.
                #[derive(Clone, PartialEq, ::prost::Oneof)]
                pub enum Content {
                    /// Unstructured document information.
                    #[prost(message, tag = "1")]
                    UnstructuredDocumentInfo(UnstructuredDocumentInfo),
                    /// Chunk information.
                    #[prost(message, tag = "2")]
                    ChunkInfo(ChunkInfo),
                }
            }
        }
        /// Search parameters to control the search behavior.
        /// Or provide search result list to generate answer.
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum Input {
            /// Search parameters.
            #[prost(message, tag = "1")]
            SearchParams(SearchParams),
            /// Search result list.
            #[prost(message, tag = "2")]
            SearchResultList(SearchResultList),
        }
    }
    /// Query understanding specification.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct QueryUnderstandingSpec {
        /// Query classification specification.
        #[prost(message, optional, tag = "1")]
        pub query_classification_spec: ::core::option::Option<
            query_understanding_spec::QueryClassificationSpec,
        >,
        /// Query rephraser specification.
        #[prost(message, optional, tag = "2")]
        pub query_rephraser_spec: ::core::option::Option<
            query_understanding_spec::QueryRephraserSpec,
        >,
    }
    /// Nested message and enum types in `QueryUnderstandingSpec`.
    pub mod query_understanding_spec {
        /// Query classification specification.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct QueryClassificationSpec {
            /// Enabled query classification types.
            #[prost(
                enumeration = "query_classification_spec::Type",
                repeated,
                tag = "1"
            )]
            pub types: ::prost::alloc::vec::Vec<i32>,
        }
        /// Nested message and enum types in `QueryClassificationSpec`.
        pub mod query_classification_spec {
            /// Query classification types.
            #[derive(
                Clone,
                Copy,
                Debug,
                PartialEq,
                Eq,
                Hash,
                PartialOrd,
                Ord,
                ::prost::Enumeration
            )]
            #[repr(i32)]
            pub enum Type {
                /// Unspecified query classification type.
                Unspecified = 0,
                /// Adversarial query classification type.
                AdversarialQuery = 1,
                /// Non-answer-seeking query classification type.
                NonAnswerSeekingQuery = 2,
                /// Jail-breaking query classification type.
                JailBreakingQuery = 3,
            }
            impl Type {
                /// 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 {
                        Type::Unspecified => "TYPE_UNSPECIFIED",
                        Type::AdversarialQuery => "ADVERSARIAL_QUERY",
                        Type::NonAnswerSeekingQuery => "NON_ANSWER_SEEKING_QUERY",
                        Type::JailBreakingQuery => "JAIL_BREAKING_QUERY",
                    }
                }
                /// Creates an enum from field names used in the ProtoBuf definition.
                pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                    match value {
                        "TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                        "ADVERSARIAL_QUERY" => Some(Self::AdversarialQuery),
                        "NON_ANSWER_SEEKING_QUERY" => Some(Self::NonAnswerSeekingQuery),
                        "JAIL_BREAKING_QUERY" => Some(Self::JailBreakingQuery),
                        _ => None,
                    }
                }
            }
        }
        /// Query rephraser specification.
        #[derive(Clone, Copy, PartialEq, ::prost::Message)]
        pub struct QueryRephraserSpec {
            /// Disable query rephraser.
            #[prost(bool, tag = "1")]
            pub disable: bool,
            /// Max rephrase steps.
            /// The max number is 5 steps.
            /// If not set or set to < 1, it will be set to 1 by default.
            #[prost(int32, tag = "2")]
            pub max_rephrase_steps: i32,
        }
    }
}
/// Response message for
/// [ConversationalSearchService.AnswerQuery][google.cloud.discoveryengine.v1alpha.ConversationalSearchService.AnswerQuery]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AnswerQueryResponse {
    /// Answer resource object.
    /// If
    /// [AnswerQueryRequest.QueryUnderstandingSpec.QueryRephraserSpec.max_rephrase_steps][google.cloud.discoveryengine.v1alpha.AnswerQueryRequest.QueryUnderstandingSpec.QueryRephraserSpec.max_rephrase_steps]
    /// is greater than 1, use
    /// [Answer.name][google.cloud.discoveryengine.v1alpha.Answer.name] to fetch
    /// answer information using
    /// [ConversationalSearchService.GetAnswer][google.cloud.discoveryengine.v1alpha.ConversationalSearchService.GetAnswer]
    /// API.
    #[prost(message, optional, tag = "1")]
    pub answer: ::core::option::Option<Answer>,
    /// Session resource object.
    /// It will be only available when session field is set and valid in the
    /// [AnswerQueryRequest][google.cloud.discoveryengine.v1alpha.AnswerQueryRequest]
    /// request.
    #[prost(message, optional, tag = "2")]
    pub session: ::core::option::Option<Session>,
    /// A global unique ID used for logging.
    #[prost(string, tag = "3")]
    pub answer_query_token: ::prost::alloc::string::String,
}
/// Request for GetAnswer method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetAnswerRequest {
    /// Required. The resource name of the Answer to get. Format:
    /// `projects/{project_number}/locations/{location_id}/collections/{collection}/engines/{engine_id}/sessions/{session_id}/answers/{answer_id}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request for CreateSession method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateSessionRequest {
    /// Required. Full resource name of parent data store. Format:
    /// `projects/{project_number}/locations/{location_id}/collections/{collection}/dataStores/{data_store_id}`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The session to create.
    #[prost(message, optional, tag = "2")]
    pub session: ::core::option::Option<Session>,
}
/// Request for UpdateSession method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateSessionRequest {
    /// Required. The Session to update.
    #[prost(message, optional, tag = "1")]
    pub session: ::core::option::Option<Session>,
    /// Indicates which fields in the provided
    /// [Session][google.cloud.discoveryengine.v1alpha.Session] to update. The
    /// following are NOT supported:
    ///
    /// * [Session.name][google.cloud.discoveryengine.v1alpha.Session.name]
    ///
    /// If not set or empty, all supported fields are updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request for DeleteSession method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteSessionRequest {
    /// Required. The resource name of the Session to delete. Format:
    /// `projects/{project_number}/locations/{location_id}/collections/{collection}/dataStores/{data_store_id}/sessions/{session_id}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request for GetSession method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetSessionRequest {
    /// Required. The resource name of the Session to get. Format:
    /// `projects/{project_number}/locations/{location_id}/collections/{collection}/dataStores/{data_store_id}/sessions/{session_id}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request for ListSessions method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListSessionsRequest {
    /// Required. The data store resource name. Format:
    /// `projects/{project_number}/locations/{location_id}/collections/{collection}/dataStores/{data_store_id}`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Maximum number of results to return. If unspecified, defaults
    /// to 50. Max allowed value is 1000.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// A page token, received from a previous `ListSessions` call.
    /// Provide this to retrieve the subsequent page.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// A filter to apply on the list results. The supported features are:
    /// user_pseudo_id, state.
    ///
    /// Example:
    /// "user_pseudo_id = some_id"
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
    /// A comma-separated list of fields to order by, sorted in ascending order.
    /// Use "desc" after a field name for descending.
    /// Supported fields:
    ///    * `update_time`
    ///    * `create_time`
    ///    * `session_name`
    ///
    /// Example:
    /// "update_time desc"
    /// "create_time"
    #[prost(string, tag = "5")]
    pub order_by: ::prost::alloc::string::String,
}
/// Response for ListSessions method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListSessionsResponse {
    /// All the Sessions for a given data store.
    #[prost(message, repeated, tag = "1")]
    pub sessions: ::prost::alloc::vec::Vec<Session>,
    /// Pagination token, if not returned indicates the last page.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod conversational_search_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for conversational search.
    #[derive(Debug, Clone)]
    pub struct ConversationalSearchServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl<T> ConversationalSearchServiceClient<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,
        ) -> ConversationalSearchServiceClient<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,
        {
            ConversationalSearchServiceClient::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
        }
        /// Converses a conversation.
        pub async fn converse_conversation(
            &mut self,
            request: impl tonic::IntoRequest<super::ConverseConversationRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ConverseConversationResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.ConversationalSearchService/ConverseConversation",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.ConversationalSearchService",
                        "ConverseConversation",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a Conversation.
        ///
        /// If the [Conversation][google.cloud.discoveryengine.v1alpha.Conversation] to
        /// create already exists, an ALREADY_EXISTS error is returned.
        pub async fn create_conversation(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateConversationRequest>,
        ) -> std::result::Result<tonic::Response<super::Conversation>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.ConversationalSearchService/CreateConversation",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.ConversationalSearchService",
                        "CreateConversation",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes a Conversation.
        ///
        /// If the [Conversation][google.cloud.discoveryengine.v1alpha.Conversation] to
        /// delete does not exist, a NOT_FOUND error is returned.
        pub async fn delete_conversation(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteConversationRequest>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.ConversationalSearchService/DeleteConversation",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.ConversationalSearchService",
                        "DeleteConversation",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates a Conversation.
        ///
        /// [Conversation][google.cloud.discoveryengine.v1alpha.Conversation] action
        /// type cannot be changed. If the
        /// [Conversation][google.cloud.discoveryengine.v1alpha.Conversation] to update
        /// does not exist, a NOT_FOUND error is returned.
        pub async fn update_conversation(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateConversationRequest>,
        ) -> std::result::Result<tonic::Response<super::Conversation>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.ConversationalSearchService/UpdateConversation",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.ConversationalSearchService",
                        "UpdateConversation",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets a Conversation.
        pub async fn get_conversation(
            &mut self,
            request: impl tonic::IntoRequest<super::GetConversationRequest>,
        ) -> std::result::Result<tonic::Response<super::Conversation>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.ConversationalSearchService/GetConversation",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.ConversationalSearchService",
                        "GetConversation",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists all Conversations by their parent
        /// [DataStore][google.cloud.discoveryengine.v1alpha.DataStore].
        pub async fn list_conversations(
            &mut self,
            request: impl tonic::IntoRequest<super::ListConversationsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListConversationsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.ConversationalSearchService/ListConversations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.ConversationalSearchService",
                        "ListConversations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Answer query method.
        pub async fn answer_query(
            &mut self,
            request: impl tonic::IntoRequest<super::AnswerQueryRequest>,
        ) -> std::result::Result<
            tonic::Response<super::AnswerQueryResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.ConversationalSearchService/AnswerQuery",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.ConversationalSearchService",
                        "AnswerQuery",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets a Answer.
        pub async fn get_answer(
            &mut self,
            request: impl tonic::IntoRequest<super::GetAnswerRequest>,
        ) -> std::result::Result<tonic::Response<super::Answer>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.ConversationalSearchService/GetAnswer",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.ConversationalSearchService",
                        "GetAnswer",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a Session.
        ///
        /// If the [Session][google.cloud.discoveryengine.v1alpha.Session] to create
        /// already exists, an ALREADY_EXISTS error is returned.
        pub async fn create_session(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateSessionRequest>,
        ) -> std::result::Result<tonic::Response<super::Session>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.ConversationalSearchService/CreateSession",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.ConversationalSearchService",
                        "CreateSession",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes a Session.
        ///
        /// If the [Session][google.cloud.discoveryengine.v1alpha.Session] to delete
        /// does not exist, a NOT_FOUND error is returned.
        pub async fn delete_session(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteSessionRequest>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.ConversationalSearchService/DeleteSession",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.ConversationalSearchService",
                        "DeleteSession",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates a Session.
        ///
        /// [Session][google.cloud.discoveryengine.v1alpha.Session] action type cannot
        /// be changed. If the [Session][google.cloud.discoveryengine.v1alpha.Session]
        /// to update does not exist, a NOT_FOUND error is returned.
        pub async fn update_session(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateSessionRequest>,
        ) -> std::result::Result<tonic::Response<super::Session>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.ConversationalSearchService/UpdateSession",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.ConversationalSearchService",
                        "UpdateSession",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets a Session.
        pub async fn get_session(
            &mut self,
            request: impl tonic::IntoRequest<super::GetSessionRequest>,
        ) -> std::result::Result<tonic::Response<super::Session>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.ConversationalSearchService/GetSession",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.ConversationalSearchService",
                        "GetSession",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists all Sessions by their parent
        /// [DataStore][google.cloud.discoveryengine.v1alpha.DataStore].
        pub async fn list_sessions(
            &mut self,
            request: impl tonic::IntoRequest<super::ListSessionsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListSessionsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.ConversationalSearchService/ListSessions",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.ConversationalSearchService",
                        "ListSessions",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Request message for
/// [SampleQueryService.GetSampleQuery][google.cloud.discoveryengine.v1alpha.SampleQueryService.GetSampleQuery]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetSampleQueryRequest {
    /// Required. Full resource name of
    /// [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery], such as
    /// `projects/{project}/locations/{location}/sampleQuerySets/{sample_query_set}/sampleQueries/{sample_query}`.
    ///
    /// If the caller does not have permission to access the
    /// [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery], regardless
    /// of whether or not it exists, a PERMISSION_DENIED error is returned.
    ///
    /// If the requested
    /// [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery] does not
    /// exist, a NOT_FOUND error is returned.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for
/// [SampleQueryService.ListSampleQueries][google.cloud.discoveryengine.v1alpha.SampleQueryService.ListSampleQueries]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListSampleQueriesRequest {
    /// Required. The parent sample query set resource name, such as
    /// `projects/{project}/locations/{location}/sampleQuerySets/{sampleQuerySet}`.
    ///
    /// If the caller does not have permission to list
    /// [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery]s under this
    /// sample query set, regardless of whether or not this sample query set
    /// exists, a `PERMISSION_DENIED` error is returned.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Maximum number of
    /// [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery]s to return.
    /// If unspecified, defaults to 100. The maximum allowed value is 1000. Values
    /// above 1000 will be coerced to 1000.
    ///
    /// If this field is negative, an `INVALID_ARGUMENT` error is returned.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// A page token
    /// [ListSampleQueriesResponse.next_page_token][google.cloud.discoveryengine.v1alpha.ListSampleQueriesResponse.next_page_token],
    /// received from a previous
    /// [SampleQueryService.ListSampleQueries][google.cloud.discoveryengine.v1alpha.SampleQueryService.ListSampleQueries]
    /// call. Provide this to retrieve the subsequent page.
    ///
    /// When paginating, all other parameters provided to
    /// [SampleQueryService.ListSampleQueries][google.cloud.discoveryengine.v1alpha.SampleQueryService.ListSampleQueries]
    /// must match the call that provided the page token. Otherwise, an
    /// `INVALID_ARGUMENT` error is returned.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// Response message for
/// [SampleQueryService.ListSampleQueries][google.cloud.discoveryengine.v1alpha.SampleQueryService.ListSampleQueries]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListSampleQueriesResponse {
    /// The [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery]s.
    #[prost(message, repeated, tag = "1")]
    pub sample_queries: ::prost::alloc::vec::Vec<SampleQuery>,
    /// A token that can be sent as
    /// [ListSampleQueriesRequest.page_token][google.cloud.discoveryengine.v1alpha.ListSampleQueriesRequest.page_token]
    /// to retrieve the next page. If this field is omitted, there are no
    /// subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for
/// [SampleQueryService.CreateSampleQuery][google.cloud.discoveryengine.v1alpha.SampleQueryService.CreateSampleQuery]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateSampleQueryRequest {
    /// Required. The parent resource name, such as
    /// `projects/{project}/locations/{location}/sampleQuerySets/{sampleQuerySet}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The
    /// [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery] to create.
    #[prost(message, optional, tag = "2")]
    pub sample_query: ::core::option::Option<SampleQuery>,
    /// Required. The ID to use for the
    /// [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery], which will
    /// become the final component of the
    /// [SampleQuery.name][google.cloud.discoveryengine.v1alpha.SampleQuery.name].
    ///
    /// If the caller does not have permission to create the
    /// [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery], regardless
    /// of whether or not it exists, a `PERMISSION_DENIED` error is returned.
    ///
    /// This field must be unique among all
    /// [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery]s with the
    /// same
    /// [parent][google.cloud.discoveryengine.v1alpha.CreateSampleQueryRequest.parent].
    /// Otherwise, an `ALREADY_EXISTS` error is returned.
    ///
    /// This field must conform to [RFC-1034](<https://tools.ietf.org/html/rfc1034>)
    /// standard with a length limit of 63 characters. Otherwise, an
    /// `INVALID_ARGUMENT` error is returned.
    #[prost(string, tag = "3")]
    pub sample_query_id: ::prost::alloc::string::String,
}
/// Request message for
/// [SampleQueryService.UpdateSampleQuery][google.cloud.discoveryengine.v1alpha.SampleQueryService.UpdateSampleQuery]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateSampleQueryRequest {
    /// Required. The simple query to update.
    ///
    /// If the caller does not have permission to update the
    /// [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery], regardless
    /// of whether or not it exists, a `PERMISSION_DENIED` error is returned.
    ///
    /// If the [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery] to
    /// update does not exist a `NOT_FOUND` error is returned.
    #[prost(message, optional, tag = "1")]
    pub sample_query: ::core::option::Option<SampleQuery>,
    /// Indicates which fields in the provided imported 'simple query' to update.
    /// If not set, will by default update all fields.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request message for
/// [SampleQueryService.DeleteSampleQuery][google.cloud.discoveryengine.v1alpha.SampleQueryService.DeleteSampleQuery]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteSampleQueryRequest {
    /// Required. Full resource name of
    /// [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery], such as
    /// `projects/{project}/locations/{location}/sampleQuerySets/{sample_query_set}/sampleQueries/{sample_query}`.
    ///
    /// If the caller does not have permission to delete the
    /// [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery], regardless
    /// of whether or not it exists, a `PERMISSION_DENIED` error is returned.
    ///
    /// If the [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery] to
    /// delete does not exist, a `NOT_FOUND` error is returned.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod sample_query_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for managing
    /// [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery]s,
    #[derive(Debug, Clone)]
    pub struct SampleQueryServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl<T> SampleQueryServiceClient<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,
        ) -> SampleQueryServiceClient<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,
        {
            SampleQueryServiceClient::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
        }
        /// Gets a [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery].
        pub async fn get_sample_query(
            &mut self,
            request: impl tonic::IntoRequest<super::GetSampleQueryRequest>,
        ) -> std::result::Result<tonic::Response<super::SampleQuery>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.SampleQueryService/GetSampleQuery",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.SampleQueryService",
                        "GetSampleQuery",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets a list of
        /// [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery]s.
        pub async fn list_sample_queries(
            &mut self,
            request: impl tonic::IntoRequest<super::ListSampleQueriesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListSampleQueriesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.SampleQueryService/ListSampleQueries",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.SampleQueryService",
                        "ListSampleQueries",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery]
        pub async fn create_sample_query(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateSampleQueryRequest>,
        ) -> std::result::Result<tonic::Response<super::SampleQuery>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.SampleQueryService/CreateSampleQuery",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.SampleQueryService",
                        "CreateSampleQuery",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates a [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery].
        pub async fn update_sample_query(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateSampleQueryRequest>,
        ) -> std::result::Result<tonic::Response<super::SampleQuery>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.SampleQueryService/UpdateSampleQuery",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.SampleQueryService",
                        "UpdateSampleQuery",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes a [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery].
        pub async fn delete_sample_query(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteSampleQueryRequest>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.SampleQueryService/DeleteSampleQuery",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.SampleQueryService",
                        "DeleteSampleQuery",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Bulk import of multiple
        /// [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery]s. Sample
        /// queries that already exist may be deleted.
        ///
        /// Note: It is possible for a subset of the
        /// [SampleQuery][google.cloud.discoveryengine.v1alpha.SampleQuery]s to be
        /// successfully imported.
        pub async fn import_sample_queries(
            &mut self,
            request: impl tonic::IntoRequest<super::ImportSampleQueriesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.SampleQueryService/ImportSampleQueries",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.SampleQueryService",
                        "ImportSampleQueries",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Grounding Fact.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GroundingFact {
    /// Text content of the fact. Can be at most 10K characters long.
    #[prost(string, tag = "1")]
    pub fact_text: ::prost::alloc::string::String,
    /// Attributes associated with the fact.
    /// Common attributes include `source` (indicating where the fact was sourced
    /// from), `author` (indicating the author of the fact), and so on.
    #[prost(btree_map = "string, string", tag = "2")]
    pub attributes: ::prost::alloc::collections::BTreeMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
/// Fact Chunk.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FactChunk {
    /// Text content of the fact chunk. Can be at most 10K characters long.
    #[prost(string, tag = "1")]
    pub chunk_text: ::prost::alloc::string::String,
    /// Source from which this fact chunk was retrieved. If it was retrieved
    /// from the GroundingFacts provided in the request then this field will
    /// contain the index of the specific fact from which this chunk was
    /// retrieved.
    #[prost(string, tag = "2")]
    pub source: ::prost::alloc::string::String,
    /// The index of this chunk. Currently, only used for the streaming mode.
    #[prost(int32, tag = "4")]
    pub index: i32,
    /// More fine-grained information for the source reference.
    #[prost(btree_map = "string, string", tag = "3")]
    pub source_metadata: ::prost::alloc::collections::BTreeMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
/// Specification for the grounding check.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct CheckGroundingSpec {
    /// The threshold (in \[0,1\]) used for determining whether a fact must be
    /// cited for a claim in the answer candidate. Choosing a higher threshold
    /// will lead to fewer but very strong citations, while choosing a lower
    /// threshold may lead to more but somewhat weaker citations. If unset, the
    /// threshold will default to 0.6.
    #[prost(double, optional, tag = "1")]
    pub citation_threshold: ::core::option::Option<f64>,
}
/// Request message for
/// [GroundedGenerationService.CheckGrounding][google.cloud.discoveryengine.v1alpha.GroundedGenerationService.CheckGrounding]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CheckGroundingRequest {
    /// Required. The resource name of the grounding config, such as
    /// `projects/*/locations/global/groundingConfigs/default_grounding_config`.
    #[prost(string, tag = "1")]
    pub grounding_config: ::prost::alloc::string::String,
    /// Answer candidate to check. Can have a maximum length of 1024 characters.
    #[prost(string, tag = "2")]
    pub answer_candidate: ::prost::alloc::string::String,
    /// List of facts for the grounding check.
    /// We support up to 200 facts.
    #[prost(message, repeated, tag = "3")]
    pub facts: ::prost::alloc::vec::Vec<GroundingFact>,
    /// Configuration of the grounding check.
    #[prost(message, optional, tag = "4")]
    pub grounding_spec: ::core::option::Option<CheckGroundingSpec>,
    /// The user labels applied to a resource must meet the following requirements:
    ///
    /// * Each resource can have multiple labels, up to a maximum of 64.
    /// * Each label must be a key-value pair.
    /// * Keys have a minimum length of 1 character and a maximum length of 63
    ///    characters and cannot be empty. Values can be empty and have a maximum
    ///    length of 63 characters.
    /// * Keys and values can contain only lowercase letters, numeric characters,
    ///    underscores, and dashes. All characters must use UTF-8 encoding, and
    ///    international characters are allowed.
    /// * The key portion of a label must be unique. However, you can use the same
    ///    key with multiple resources.
    /// * Keys must start with a lowercase letter or international character.
    ///
    /// See [Google Cloud
    /// Document](<https://cloud.google.com/resource-manager/docs/creating-managing-labels#requirements>)
    /// for more details.
    #[prost(btree_map = "string, string", tag = "5")]
    pub user_labels: ::prost::alloc::collections::BTreeMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
/// Response message for the
/// [GroundedGenerationService.CheckGrounding][google.cloud.discoveryengine.v1alpha.GroundedGenerationService.CheckGrounding]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CheckGroundingResponse {
    /// The support score for the input answer candidate.
    /// Higher the score, higher is the fraction of claims that are supported by
    /// the provided facts. This is always set when a response is returned.
    #[prost(float, optional, tag = "1")]
    pub support_score: ::core::option::Option<f32>,
    /// List of facts cited across all claims in the answer candidate.
    /// These are derived from the facts supplied in the request.
    #[prost(message, repeated, tag = "3")]
    pub cited_chunks: ::prost::alloc::vec::Vec<FactChunk>,
    /// Claim texts and citation info across all claims in the answer candidate.
    #[prost(message, repeated, tag = "4")]
    pub claims: ::prost::alloc::vec::Vec<check_grounding_response::Claim>,
}
/// Nested message and enum types in `CheckGroundingResponse`.
pub mod check_grounding_response {
    /// Text and citation info for a claim in the answer candidate.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Claim {
        /// Position indicating the start of the claim in the answer candidate,
        /// measured in bytes.
        #[prost(int32, optional, tag = "1")]
        pub start_pos: ::core::option::Option<i32>,
        /// Position indicating the end of the claim in the answer candidate,
        /// exclusive.
        #[prost(int32, optional, tag = "2")]
        pub end_pos: ::core::option::Option<i32>,
        /// Text for the claim in the answer candidate. Always provided regardless of
        /// whether citations or anti-citations are found.
        #[prost(string, tag = "3")]
        pub claim_text: ::prost::alloc::string::String,
        /// A list of indices (into 'cited_chunks') specifying the citations
        /// associated with the claim. For instance \[1,3,4\] means that
        /// cited_chunks\[1\], cited_chunks\[3\], cited_chunks\[4\] are the facts cited
        /// supporting for the claim. A citation to a fact indicates that the claim
        /// is supported by the fact.
        #[prost(int32, repeated, tag = "4")]
        pub citation_indices: ::prost::alloc::vec::Vec<i32>,
        /// Indicates that this claim required grounding check. When the system
        /// decided this claim doesn't require attribution/grounding check, this
        /// field will be set to false. In that case, no grounding check was done for
        /// the claim and therefore
        /// [citation_indices][google.cloud.discoveryengine.v1alpha.CheckGroundingResponse.Claim.citation_indices],
        /// [anti_citation_indices][google.cloud.discoveryengine.v1alpha.CheckGroundingResponse.Claim.anti_citation_indices],
        /// and
        /// [score][google.cloud.discoveryengine.v1alpha.CheckGroundingResponse.Claim.score]
        /// should not be returned.
        #[prost(bool, optional, tag = "6")]
        pub grounding_check_required: ::core::option::Option<bool>,
    }
}
/// Generated client implementations.
pub mod grounded_generation_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for grounded generation.
    #[derive(Debug, Clone)]
    pub struct GroundedGenerationServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl<T> GroundedGenerationServiceClient<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,
        ) -> GroundedGenerationServiceClient<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,
        {
            GroundedGenerationServiceClient::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
        }
        /// Performs a grounding check.
        pub async fn check_grounding(
            &mut self,
            request: impl tonic::IntoRequest<super::CheckGroundingRequest>,
        ) -> std::result::Result<
            tonic::Response<super::CheckGroundingResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.GroundedGenerationService/CheckGrounding",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.GroundedGenerationService",
                        "CheckGrounding",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Request message for WriteUserEvent method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WriteUserEventRequest {
    /// Required. The parent resource name.
    /// If the write user event action is applied in
    /// [DataStore][google.cloud.discoveryengine.v1alpha.DataStore] level, the
    /// format is:
    /// `projects/{project}/locations/{location}/collections/{collection}/dataStores/{data_store}`.
    /// If the write user event action is applied in [Location][] level, for
    /// example, the event with
    /// [Document][google.cloud.discoveryengine.v1alpha.Document] across multiple
    /// [DataStore][google.cloud.discoveryengine.v1alpha.DataStore], the format is:
    /// `projects/{project}/locations/{location}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. User event to write.
    #[prost(message, optional, tag = "2")]
    pub user_event: ::core::option::Option<UserEvent>,
    /// If set to true, the user event is written asynchronously after
    /// validation, and the API responds without waiting for the write.
    #[prost(bool, tag = "3")]
    pub write_async: bool,
}
/// Request message for CollectUserEvent method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CollectUserEventRequest {
    /// Required. The parent DataStore resource name, such as
    /// `projects/{project}/locations/{location}/collections/{collection}/dataStores/{data_store}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. URL encoded UserEvent proto with a length limit of 2,000,000
    /// characters.
    #[prost(string, tag = "2")]
    pub user_event: ::prost::alloc::string::String,
    /// The URL including cgi-parameters but excluding the hash fragment with a
    /// length limit of 5,000 characters. This is often more useful than the
    /// referer URL, because many browsers only send the domain for third-party
    /// requests.
    #[prost(string, optional, tag = "3")]
    pub uri: ::core::option::Option<::prost::alloc::string::String>,
    /// The event timestamp in milliseconds. This prevents browser caching of
    /// otherwise identical get requests. The name is abbreviated to reduce the
    /// payload bytes.
    #[prost(int64, optional, tag = "4")]
    pub ets: ::core::option::Option<i64>,
}
/// Generated client implementations.
pub mod user_event_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for ingesting end user actions on a website to Discovery Engine API.
    #[derive(Debug, Clone)]
    pub struct UserEventServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl<T> UserEventServiceClient<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,
        ) -> UserEventServiceClient<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,
        {
            UserEventServiceClient::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
        }
        /// Writes a single user event.
        pub async fn write_user_event(
            &mut self,
            request: impl tonic::IntoRequest<super::WriteUserEventRequest>,
        ) -> std::result::Result<tonic::Response<super::UserEvent>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.UserEventService/WriteUserEvent",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.UserEventService",
                        "WriteUserEvent",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Writes a single user event from the browser. This uses a GET request to
        /// due to browser restriction of POST-ing to a third-party domain.
        ///
        /// This method is used only by the Discovery Engine API JavaScript pixel and
        /// Google Tag Manager. Users should not call this method directly.
        pub async fn collect_user_event(
            &mut self,
            request: impl tonic::IntoRequest<super::CollectUserEventRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::api::HttpBody>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.UserEventService/CollectUserEvent",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.UserEventService",
                        "CollectUserEvent",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes permanently all user events specified by the filter provided.
        /// Depending on the number of events specified by the filter, this operation
        /// could take hours or days to complete. To test a filter, use the list
        /// command first.
        pub async fn purge_user_events(
            &mut self,
            request: impl tonic::IntoRequest<super::PurgeUserEventsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.UserEventService/PurgeUserEvents",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.UserEventService",
                        "PurgeUserEvents",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Bulk import of user events. Request processing might be
        /// synchronous. Events that already exist are skipped.
        /// Use this method for backfilling historical user events.
        ///
        /// Operation.response is of type ImportResponse. Note that it is
        /// possible for a subset of the items to be successfully inserted.
        /// Operation.metadata is of type ImportMetadata.
        pub async fn import_user_events(
            &mut self,
            request: impl tonic::IntoRequest<super::ImportUserEventsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.UserEventService/ImportUserEvents",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.UserEventService",
                        "ImportUserEvents",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Request for
/// [EngineService.CreateEngine][google.cloud.discoveryengine.v1alpha.EngineService.CreateEngine]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateEngineRequest {
    /// Required. The parent resource name, such as
    /// `projects/{project}/locations/{location}/collections/{collection}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The [Engine][google.cloud.discoveryengine.v1alpha.Engine] to
    /// create.
    #[prost(message, optional, tag = "2")]
    pub engine: ::core::option::Option<Engine>,
    /// Required. The ID to use for the
    /// [Engine][google.cloud.discoveryengine.v1alpha.Engine], which will become
    /// the final component of the
    /// [Engine][google.cloud.discoveryengine.v1alpha.Engine]'s resource name.
    ///
    /// This field must conform to [RFC-1034](<https://tools.ietf.org/html/rfc1034>)
    /// standard with a length limit of 63 characters. Otherwise, an
    /// INVALID_ARGUMENT error is returned.
    #[prost(string, tag = "3")]
    pub engine_id: ::prost::alloc::string::String,
}
/// Metadata related to the progress of the
/// [EngineService.CreateEngine][google.cloud.discoveryengine.v1alpha.EngineService.CreateEngine]
/// operation. This will be returned by the google.longrunning.Operation.metadata
/// field.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct CreateEngineMetadata {
    /// Operation create time.
    #[prost(message, optional, tag = "1")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Operation last update time. If the operation is done, this is also the
    /// finish time.
    #[prost(message, optional, tag = "2")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Request message for
/// [EngineService.DeleteEngine][google.cloud.discoveryengine.v1alpha.EngineService.DeleteEngine]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteEngineRequest {
    /// Required. Full resource name of
    /// [Engine][google.cloud.discoveryengine.v1alpha.Engine], such as
    /// `projects/{project}/locations/{location}/collections/{collection_id}/engines/{engine_id}`.
    ///
    /// If the caller does not have permission to delete the
    /// [Engine][google.cloud.discoveryengine.v1alpha.Engine], regardless of
    /// whether or not it exists, a PERMISSION_DENIED error is returned.
    ///
    /// If the [Engine][google.cloud.discoveryengine.v1alpha.Engine] to delete does
    /// not exist, a NOT_FOUND error is returned.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Metadata related to the progress of the
/// [EngineService.DeleteEngine][google.cloud.discoveryengine.v1alpha.EngineService.DeleteEngine]
/// operation. This will be returned by the google.longrunning.Operation.metadata
/// field.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct DeleteEngineMetadata {
    /// Operation create time.
    #[prost(message, optional, tag = "1")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Operation last update time. If the operation is done, this is also the
    /// finish time.
    #[prost(message, optional, tag = "2")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Request message for
/// [EngineService.GetEngine][google.cloud.discoveryengine.v1alpha.EngineService.GetEngine]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetEngineRequest {
    /// Required. Full resource name of
    /// [Engine][google.cloud.discoveryengine.v1alpha.Engine], such as
    /// `projects/{project}/locations/{location}/collections/{collection_id}/engines/{engine_id}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for
/// [EngineService.ListEngines][google.cloud.discoveryengine.v1alpha.EngineService.ListEngines]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListEnginesRequest {
    /// Required. The parent resource name, such as
    /// `projects/{project}/locations/{location}/collections/{collection_id}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. Not supported.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. Not supported.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Optional. Filter by solution type. For example:
    /// solution_type=SOLUTION_TYPE_SEARCH
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
}
/// Response message for
/// [EngineService.ListEngines][google.cloud.discoveryengine.v1alpha.EngineService.ListEngines]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListEnginesResponse {
    /// All the customer's [Engine][google.cloud.discoveryengine.v1alpha.Engine]s.
    #[prost(message, repeated, tag = "1")]
    pub engines: ::prost::alloc::vec::Vec<Engine>,
    /// Not supported.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for
/// [EngineService.UpdateEngine][google.cloud.discoveryengine.v1alpha.EngineService.UpdateEngine]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateEngineRequest {
    /// Required. The [Engine][google.cloud.discoveryengine.v1alpha.Engine] to
    /// update.
    ///
    /// If the caller does not have permission to update the
    /// [Engine][google.cloud.discoveryengine.v1alpha.Engine], regardless of
    /// whether or not it exists, a PERMISSION_DENIED error is returned.
    ///
    /// If the [Engine][google.cloud.discoveryengine.v1alpha.Engine] to update does
    /// not exist, a NOT_FOUND error is returned.
    #[prost(message, optional, tag = "1")]
    pub engine: ::core::option::Option<Engine>,
    /// Indicates which fields in the provided
    /// [Engine][google.cloud.discoveryengine.v1alpha.Engine] to update.
    ///
    /// If an unsupported or unknown field is provided, an INVALID_ARGUMENT error
    /// is returned.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request for pausing training of an engine.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PauseEngineRequest {
    /// Required. The name of the engine to pause.
    /// Format:
    /// `projects/{project_number}/locations/{location_id}/collections/{collection_id}/engines/{engine_id}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request for resuming training of an engine.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResumeEngineRequest {
    /// Required. The name of the engine to resume.
    /// Format:
    /// `projects/{project_number}/locations/{location_id}/collections/{collection_id}/engines/{engine_id}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request to manually start a tuning process now (instead of waiting for
/// the periodically scheduled tuning to happen).
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TuneEngineRequest {
    /// Required. The resource name of the engine to tune.
    /// Format:
    /// `projects/{project_number}/locations/{location_id}/collections/{collection_id}/engines/{engine_id}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Metadata associated with a tune operation.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TuneEngineMetadata {
    /// Required. The resource name of the engine that this tune applies to.
    /// Format:
    /// `projects/{project_number}/locations/{location_id}/collections/{collection_id}/engines/{engine_id}`
    #[prost(string, tag = "1")]
    pub engine: ::prost::alloc::string::String,
}
/// Response associated with a tune operation.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct TuneEngineResponse {}
/// Generated client implementations.
pub mod engine_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for managing [Engine][google.cloud.discoveryengine.v1alpha.Engine]
    /// configuration.
    #[derive(Debug, Clone)]
    pub struct EngineServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl<T> EngineServiceClient<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,
        ) -> EngineServiceClient<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,
        {
            EngineServiceClient::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
        }
        /// Creates a [Engine][google.cloud.discoveryengine.v1alpha.Engine].
        pub async fn create_engine(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateEngineRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.EngineService/CreateEngine",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.EngineService",
                        "CreateEngine",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes a [Engine][google.cloud.discoveryengine.v1alpha.Engine].
        pub async fn delete_engine(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteEngineRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.EngineService/DeleteEngine",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.EngineService",
                        "DeleteEngine",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates an [Engine][google.cloud.discoveryengine.v1alpha.Engine]
        pub async fn update_engine(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateEngineRequest>,
        ) -> std::result::Result<tonic::Response<super::Engine>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.EngineService/UpdateEngine",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.EngineService",
                        "UpdateEngine",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets a [Engine][google.cloud.discoveryengine.v1alpha.Engine].
        pub async fn get_engine(
            &mut self,
            request: impl tonic::IntoRequest<super::GetEngineRequest>,
        ) -> std::result::Result<tonic::Response<super::Engine>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.EngineService/GetEngine",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.EngineService",
                        "GetEngine",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists all the [Engine][google.cloud.discoveryengine.v1alpha.Engine]s
        /// associated with the project.
        pub async fn list_engines(
            &mut self,
            request: impl tonic::IntoRequest<super::ListEnginesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListEnginesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.EngineService/ListEngines",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.EngineService",
                        "ListEngines",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Pauses the training of an existing engine. Only applicable if
        /// [SolutionType][google.cloud.discoveryengine.v1alpha.SolutionType] is
        /// [SOLUTION_TYPE_RECOMMENDATION][google.cloud.discoveryengine.v1alpha.SolutionType.SOLUTION_TYPE_RECOMMENDATION].
        pub async fn pause_engine(
            &mut self,
            request: impl tonic::IntoRequest<super::PauseEngineRequest>,
        ) -> std::result::Result<tonic::Response<super::Engine>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.EngineService/PauseEngine",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.EngineService",
                        "PauseEngine",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Resumes the training of an existing engine. Only applicable if
        /// [SolutionType][google.cloud.discoveryengine.v1alpha.SolutionType] is
        /// [SOLUTION_TYPE_RECOMMENDATION][google.cloud.discoveryengine.v1alpha.SolutionType.SOLUTION_TYPE_RECOMMENDATION].
        pub async fn resume_engine(
            &mut self,
            request: impl tonic::IntoRequest<super::ResumeEngineRequest>,
        ) -> std::result::Result<tonic::Response<super::Engine>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.EngineService/ResumeEngine",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.EngineService",
                        "ResumeEngine",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Tunes an existing engine. Only applicable if
        /// [SolutionType][google.cloud.discoveryengine.v1alpha.SolutionType] is
        /// [SOLUTION_TYPE_RECOMMENDATION][google.cloud.discoveryengine.v1alpha.SolutionType.SOLUTION_TYPE_RECOMMENDATION].
        pub async fn tune_engine(
            &mut self,
            request: impl tonic::IntoRequest<super::TuneEngineRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.EngineService/TuneEngine",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.EngineService",
                        "TuneEngine",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Request message for GetAclConfigRequest method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetAclConfigRequest {
    /// Required. Resource name of
    /// [AclConfig][google.cloud.discoveryengine.v1alpha.AclConfig], such as
    /// `projects/*/locations/*/aclConfig`.
    ///
    /// If the caller does not have permission to access the
    /// [AclConfig][google.cloud.discoveryengine.v1alpha.AclConfig], regardless of
    /// whether or not it exists, a PERMISSION_DENIED error is returned.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for UpdateAclConfig method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateAclConfigRequest {
    #[prost(message, optional, tag = "1")]
    pub acl_config: ::core::option::Option<AclConfig>,
}
/// Generated client implementations.
pub mod acl_config_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for managing Acl Configuration.
    #[derive(Debug, Clone)]
    pub struct AclConfigServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl<T> AclConfigServiceClient<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,
        ) -> AclConfigServiceClient<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,
        {
            AclConfigServiceClient::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
        }
        /// Default ACL configuration for use in a location of a customer's project.
        /// Updates will only reflect to new data stores. Existing data stores will
        /// still use the old value.
        pub async fn update_acl_config(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateAclConfigRequest>,
        ) -> std::result::Result<tonic::Response<super::AclConfig>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.AclConfigService/UpdateAclConfig",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.AclConfigService",
                        "UpdateAclConfig",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets the [AclConfig][google.cloud.discoveryengine.v1alpha.AclConfig].
        pub async fn get_acl_config(
            &mut self,
            request: impl tonic::IntoRequest<super::GetAclConfigRequest>,
        ) -> std::result::Result<tonic::Response<super::AclConfig>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.AclConfigService/GetAclConfig",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.AclConfigService",
                        "GetAclConfig",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Request message for
/// [ProjectService.GetProject][google.cloud.discoveryengine.v1alpha.ProjectService.GetProject]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetProjectRequest {
    /// Required. Full resource name of a
    /// [Project][google.cloud.discoveryengine.v1alpha.Project], such as
    /// `projects/{project_id_or_number}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request for
/// [ProjectService.ProvisionProject][google.cloud.discoveryengine.v1alpha.ProjectService.ProvisionProject]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ProvisionProjectRequest {
    /// Required. Full resource name of a
    /// [Project][google.cloud.discoveryengine.v1alpha.Project], such as
    /// `projects/{project_id_or_number}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. Set to `true` to specify that caller has read and would like to
    /// give consent to the [Terms for data
    /// use](<https://cloud.google.com/retail/data-use-terms>).
    #[prost(bool, tag = "2")]
    pub accept_data_use_terms: bool,
    /// Required. The version of the [Terms for data
    /// use](<https://cloud.google.com/retail/data-use-terms>) that caller has read
    /// and would like to give consent to.
    ///
    /// Acceptable version is `2022-11-23`, and this may change over time.
    #[prost(string, tag = "3")]
    pub data_use_terms_version: ::prost::alloc::string::String,
}
/// Metadata associated with a project provision operation.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ProvisionProjectMetadata {}
/// Request for ReportConsentChange method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ReportConsentChangeRequest {
    /// Required. Whether customer decides to accept or decline service term.
    ///
    /// At this moment, only accept action is supported.
    #[prost(
        enumeration = "report_consent_change_request::ConsentChangeAction",
        tag = "1"
    )]
    pub consent_change_action: i32,
    /// Required. Full resource name of a
    /// [Project][google.cloud.discoveryengine.v1alpha.Project], such as
    /// `projects/{project_id_or_number}`.
    #[prost(string, tag = "2")]
    pub project: ::prost::alloc::string::String,
    /// Required. The unique identifier of the terms of service to update.
    /// Available term ids:
    ///
    /// * `GA_DATA_USE_TERMS`: [Terms for data
    /// use](<https://cloud.google.com/retail/data-use-terms>). When using this
    /// service term id, the acceptable
    /// [service_term_version][google.cloud.discoveryengine.v1alpha.ReportConsentChangeRequest.service_term_version]
    /// to provide is `2022-11-23`.
    #[prost(string, tag = "3")]
    pub service_term_id: ::prost::alloc::string::String,
    /// Required. The version string of the terms of service to update.
    #[prost(string, tag = "4")]
    pub service_term_version: ::prost::alloc::string::String,
}
/// Nested message and enum types in `ReportConsentChangeRequest`.
pub mod report_consent_change_request {
    /// Type of consent acknowledgement (accept / reject).
    ///
    /// At this moment, only `ACCEPT` action is supported.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ConsentChangeAction {
        /// Invalid action, user must specify accept/decline
        Unspecified = 0,
        /// User accepts service terms.
        Accept = 1,
    }
    impl ConsentChangeAction {
        /// 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 {
                ConsentChangeAction::Unspecified => "CONSENT_CHANGE_ACTION_UNSPECIFIED",
                ConsentChangeAction::Accept => "ACCEPT",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "CONSENT_CHANGE_ACTION_UNSPECIFIED" => Some(Self::Unspecified),
                "ACCEPT" => Some(Self::Accept),
                _ => None,
            }
        }
    }
}
/// Generated client implementations.
pub mod project_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for operations on the
    /// [Project][google.cloud.discoveryengine.v1alpha.Project].
    #[derive(Debug, Clone)]
    pub struct ProjectServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl<T> ProjectServiceClient<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,
        ) -> ProjectServiceClient<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,
        {
            ProjectServiceClient::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
        }
        /// Gets a [Project][google.cloud.discoveryengine.v1alpha.Project].
        /// Returns NOT_FOUND when the project is not yet created.
        pub async fn get_project(
            &mut self,
            request: impl tonic::IntoRequest<super::GetProjectRequest>,
        ) -> std::result::Result<tonic::Response<super::Project>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.ProjectService/GetProject",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.ProjectService",
                        "GetProject",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Provisions the project resource. During the
        /// process, related systems will get prepared and initialized.
        ///
        /// Caller must read the [Terms for data
        /// use](https://cloud.google.com/retail/data-use-terms), and optionally
        /// specify in request to provide consent to that service terms.
        pub async fn provision_project(
            &mut self,
            request: impl tonic::IntoRequest<super::ProvisionProjectRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.ProjectService/ProvisionProject",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.ProjectService",
                        "ProvisionProject",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates service terms for this project.
        ///
        /// This method can be used to retroactively accept the latest terms.
        ///
        /// Terms available for update:
        ///
        /// * [Terms for data use](https://cloud.google.com/retail/data-use-terms)
        pub async fn report_consent_change(
            &mut self,
            request: impl tonic::IntoRequest<super::ReportConsentChangeRequest>,
        ) -> std::result::Result<tonic::Response<super::Project>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.ProjectService/ReportConsentChange",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.ProjectService",
                        "ReportConsentChange",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Request message for
/// [SiteSearchEngineService.GetSiteSearchEngine][google.cloud.discoveryengine.v1alpha.SiteSearchEngineService.GetSiteSearchEngine]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetSiteSearchEngineRequest {
    /// Required. Resource name of
    /// [SiteSearchEngine][google.cloud.discoveryengine.v1alpha.SiteSearchEngine],
    /// such as
    /// `projects/{project}/locations/{location}/collections/{collection}/dataStores/{data_store}/siteSearchEngine`.
    ///
    /// If the caller does not have permission to access the \[SiteSearchEngine\],
    /// regardless of whether or not it exists, a PERMISSION_DENIED error is
    /// returned.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for
/// [SiteSearchEngineService.CreateTargetSite][google.cloud.discoveryengine.v1alpha.SiteSearchEngineService.CreateTargetSite]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateTargetSiteRequest {
    /// Required. Parent resource name of
    /// [TargetSite][google.cloud.discoveryengine.v1alpha.TargetSite], such as
    /// `projects/{project}/locations/{location}/collections/{collection}/dataStores/{data_store}/siteSearchEngine`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The [TargetSite][google.cloud.discoveryengine.v1alpha.TargetSite]
    /// to create.
    #[prost(message, optional, tag = "2")]
    pub target_site: ::core::option::Option<TargetSite>,
}
/// Metadata related to the progress of the
/// [SiteSearchEngineService.CreateTargetSite][google.cloud.discoveryengine.v1alpha.SiteSearchEngineService.CreateTargetSite]
/// operation. This will be returned by the google.longrunning.Operation.metadata
/// field.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct CreateTargetSiteMetadata {
    /// Operation create time.
    #[prost(message, optional, tag = "1")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Operation last update time. If the operation is done, this is also the
    /// finish time.
    #[prost(message, optional, tag = "2")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Request message for
/// [SiteSearchEngineService.BatchCreateTargetSites][google.cloud.discoveryengine.v1alpha.SiteSearchEngineService.BatchCreateTargetSites]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchCreateTargetSitesRequest {
    /// Required. The parent resource shared by all TargetSites being created.
    /// `projects/{project}/locations/{location}/collections/{collection}/dataStores/{data_store}/siteSearchEngine`.
    /// The parent field in the CreateBookRequest messages must either be empty or
    /// match this field.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The request message specifying the resources to create.
    /// A maximum of 20 TargetSites can be created in a batch.
    #[prost(message, repeated, tag = "2")]
    pub requests: ::prost::alloc::vec::Vec<CreateTargetSiteRequest>,
}
/// Request message for
/// [SiteSearchEngineService.GetTargetSite][google.cloud.discoveryengine.v1alpha.SiteSearchEngineService.GetTargetSite]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetTargetSiteRequest {
    /// Required. Full resource name of
    /// [TargetSite][google.cloud.discoveryengine.v1alpha.TargetSite], such as
    /// `projects/{project}/locations/{location}/collections/{collection}/dataStores/{data_store}/siteSearchEngine/targetSites/{target_site}`.
    ///
    /// If the caller does not have permission to access the
    /// [TargetSite][google.cloud.discoveryengine.v1alpha.TargetSite], regardless
    /// of whether or not it exists, a PERMISSION_DENIED error is returned.
    ///
    /// If the requested
    /// [TargetSite][google.cloud.discoveryengine.v1alpha.TargetSite] does not
    /// exist, a NOT_FOUND error is returned.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for
/// [SiteSearchEngineService.UpdateTargetSite][google.cloud.discoveryengine.v1alpha.SiteSearchEngineService.UpdateTargetSite]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateTargetSiteRequest {
    /// Required. The target site to update.
    /// If the caller does not have permission to update the
    /// [TargetSite][google.cloud.discoveryengine.v1alpha.TargetSite], regardless
    /// of whether or not it exists, a PERMISSION_DENIED error is returned.
    ///
    /// If the [TargetSite][google.cloud.discoveryengine.v1alpha.TargetSite] to
    /// update does not exist, a NOT_FOUND error is returned.
    #[prost(message, optional, tag = "1")]
    pub target_site: ::core::option::Option<TargetSite>,
}
/// Metadata related to the progress of the
/// [SiteSearchEngineService.UpdateTargetSite][google.cloud.discoveryengine.v1alpha.SiteSearchEngineService.UpdateTargetSite]
/// operation. This will be returned by the google.longrunning.Operation.metadata
/// field.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct UpdateTargetSiteMetadata {
    /// Operation create time.
    #[prost(message, optional, tag = "1")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Operation last update time. If the operation is done, this is also the
    /// finish time.
    #[prost(message, optional, tag = "2")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Request message for
/// [SiteSearchEngineService.DeleteTargetSite][google.cloud.discoveryengine.v1alpha.SiteSearchEngineService.DeleteTargetSite]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteTargetSiteRequest {
    /// Required. Full resource name of
    /// [TargetSite][google.cloud.discoveryengine.v1alpha.TargetSite], such as
    /// `projects/{project}/locations/{location}/collections/{collection}/dataStores/{data_store}/siteSearchEngine/targetSites/{target_site}`.
    ///
    /// If the caller does not have permission to access the
    /// [TargetSite][google.cloud.discoveryengine.v1alpha.TargetSite], regardless
    /// of whether or not it exists, a PERMISSION_DENIED error is returned.
    ///
    /// If the requested
    /// [TargetSite][google.cloud.discoveryengine.v1alpha.TargetSite] does not
    /// exist, a NOT_FOUND error is returned.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Metadata related to the progress of the
/// [SiteSearchEngineService.DeleteTargetSite][google.cloud.discoveryengine.v1alpha.SiteSearchEngineService.DeleteTargetSite]
/// operation. This will be returned by the google.longrunning.Operation.metadata
/// field.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct DeleteTargetSiteMetadata {
    /// Operation create time.
    #[prost(message, optional, tag = "1")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Operation last update time. If the operation is done, this is also the
    /// finish time.
    #[prost(message, optional, tag = "2")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Request message for
/// [SiteSearchEngineService.ListTargetSites][google.cloud.discoveryengine.v1alpha.SiteSearchEngineService.ListTargetSites]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListTargetSitesRequest {
    /// Required. The parent site search engine resource name, such as
    /// `projects/{project}/locations/{location}/collections/{collection}/dataStores/{data_store}/siteSearchEngine`.
    ///
    /// If the caller does not have permission to list
    /// [TargetSite][google.cloud.discoveryengine.v1alpha.TargetSite]s under this
    /// site search engine, regardless of whether or not this branch exists, a
    /// PERMISSION_DENIED error is returned.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Requested page size. Server may return fewer items than requested. If
    /// unspecified, server will pick an appropriate default. The maximum value is
    /// 1000; values above 1000 will be coerced to 1000.
    ///
    /// If this field is negative, an INVALID_ARGUMENT error is returned.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// A page token, received from a previous `ListTargetSites` call.
    /// Provide this to retrieve the subsequent page.
    ///
    /// When paginating, all other parameters provided to `ListTargetSites`
    /// must match the call that provided the page token.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// Response message for
/// [SiteSearchEngineService.ListTargetSites][google.cloud.discoveryengine.v1alpha.SiteSearchEngineService.ListTargetSites]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListTargetSitesResponse {
    /// List of TargetSites.
    #[prost(message, repeated, tag = "1")]
    pub target_sites: ::prost::alloc::vec::Vec<TargetSite>,
    /// A token that can be sent as `page_token` to retrieve the next page.
    /// If this field is omitted, there are no subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
    /// The total number of items matching the request.
    /// This will always be populated in the response.
    #[prost(int32, tag = "3")]
    pub total_size: i32,
}
/// Metadata related to the progress of the
/// [SiteSearchEngineService.BatchCreateTargetSites][google.cloud.discoveryengine.v1alpha.SiteSearchEngineService.BatchCreateTargetSites]
/// operation. This will be returned by the google.longrunning.Operation.metadata
/// field.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct BatchCreateTargetSiteMetadata {
    /// Operation create time.
    #[prost(message, optional, tag = "1")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Operation last update time. If the operation is done, this is also the
    /// finish time.
    #[prost(message, optional, tag = "2")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Response message for
/// [SiteSearchEngineService.BatchCreateTargetSites][google.cloud.discoveryengine.v1alpha.SiteSearchEngineService.BatchCreateTargetSites]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchCreateTargetSitesResponse {
    /// TargetSites created.
    #[prost(message, repeated, tag = "1")]
    pub target_sites: ::prost::alloc::vec::Vec<TargetSite>,
}
/// Request message for
/// [SiteSearchEngineService.EnableAdvancedSiteSearch][google.cloud.discoveryengine.v1alpha.SiteSearchEngineService.EnableAdvancedSiteSearch]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EnableAdvancedSiteSearchRequest {
    /// Required. Full resource name of the
    /// [SiteSearchEngine][google.cloud.discoveryengine.v1alpha.SiteSearchEngine],
    /// such as
    /// `projects/{project}/locations/{location}/dataStores/{data_store_id}/siteSearchEngine`.
    #[prost(string, tag = "1")]
    pub site_search_engine: ::prost::alloc::string::String,
}
/// Response message for
/// [SiteSearchEngineService.EnableAdvancedSiteSearch][google.cloud.discoveryengine.v1alpha.SiteSearchEngineService.EnableAdvancedSiteSearch]
/// method.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct EnableAdvancedSiteSearchResponse {}
/// Metadata related to the progress of the
/// [SiteSearchEngineService.EnableAdvancedSiteSearch][google.cloud.discoveryengine.v1alpha.SiteSearchEngineService.EnableAdvancedSiteSearch]
/// operation. This will be returned by the google.longrunning.Operation.metadata
/// field.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct EnableAdvancedSiteSearchMetadata {
    /// Operation create time.
    #[prost(message, optional, tag = "1")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Operation last update time. If the operation is done, this is also the
    /// finish time.
    #[prost(message, optional, tag = "2")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Request message for
/// [SiteSearchEngineService.DisableAdvancedSiteSearch][google.cloud.discoveryengine.v1alpha.SiteSearchEngineService.DisableAdvancedSiteSearch]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DisableAdvancedSiteSearchRequest {
    /// Required. Full resource name of the
    /// [SiteSearchEngine][google.cloud.discoveryengine.v1alpha.SiteSearchEngine],
    /// such as
    /// `projects/{project}/locations/{location}/dataStores/{data_store_id}/siteSearchEngine`.
    #[prost(string, tag = "1")]
    pub site_search_engine: ::prost::alloc::string::String,
}
/// Response message for
/// [SiteSearchEngineService.DisableAdvancedSiteSearch][google.cloud.discoveryengine.v1alpha.SiteSearchEngineService.DisableAdvancedSiteSearch]
/// method.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct DisableAdvancedSiteSearchResponse {}
/// Metadata related to the progress of the
/// [SiteSearchEngineService.DisableAdvancedSiteSearch][google.cloud.discoveryengine.v1alpha.SiteSearchEngineService.DisableAdvancedSiteSearch]
/// operation. This will be returned by the google.longrunning.Operation.metadata
/// field.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct DisableAdvancedSiteSearchMetadata {
    /// Operation create time.
    #[prost(message, optional, tag = "1")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Operation last update time. If the operation is done, this is also the
    /// finish time.
    #[prost(message, optional, tag = "2")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Request message for
/// [SiteSearchEngineService.RecrawlUris][google.cloud.discoveryengine.v1alpha.SiteSearchEngineService.RecrawlUris]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RecrawlUrisRequest {
    /// Required. Full resource name of the
    /// [SiteSearchEngine][google.cloud.discoveryengine.v1alpha.SiteSearchEngine],
    /// such as
    /// `projects/*/locations/*/collections/*/dataStores/*/siteSearchEngine`.
    #[prost(string, tag = "1")]
    pub site_search_engine: ::prost::alloc::string::String,
    /// Required. List of URIs to crawl. At most 10K URIs are supported, otherwise
    /// an INVALID_ARGUMENT error is thrown. Each URI should match at least one
    /// [TargetSite][google.cloud.discoveryengine.v1alpha.TargetSite] in
    /// `site_search_engine`.
    #[prost(string, repeated, tag = "2")]
    pub uris: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Response message for
/// [SiteSearchEngineService.RecrawlUris][google.cloud.discoveryengine.v1alpha.SiteSearchEngineService.RecrawlUris]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RecrawlUrisResponse {
    /// Details for a sample of up to 10 `failed_uris`.
    #[prost(message, repeated, tag = "1")]
    pub failure_samples: ::prost::alloc::vec::Vec<recrawl_uris_response::FailureInfo>,
    /// URIs that were not crawled before the LRO terminated.
    #[prost(string, repeated, tag = "2")]
    pub failed_uris: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Nested message and enum types in `RecrawlUrisResponse`.
pub mod recrawl_uris_response {
    /// Details about why a particular URI failed to be crawled. Each FailureInfo
    /// contains one FailureReason per CorpusType.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct FailureInfo {
        /// URI that failed to be crawled.
        #[prost(string, tag = "1")]
        pub uri: ::prost::alloc::string::String,
        /// List of failure reasons by corpus type (e.g. desktop, mobile).
        #[prost(message, repeated, tag = "2")]
        pub failure_reasons: ::prost::alloc::vec::Vec<failure_info::FailureReason>,
    }
    /// Nested message and enum types in `FailureInfo`.
    pub mod failure_info {
        /// Details about why crawling failed for a particular CorpusType, e.g.,
        /// DESKTOP and MOBILE crawling may fail for different reasons.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct FailureReason {
            /// DESKTOP, MOBILE, or CORPUS_TYPE_UNSPECIFIED.
            #[prost(enumeration = "failure_reason::CorpusType", tag = "1")]
            pub corpus_type: i32,
            /// Reason why the URI was not crawled.
            #[prost(string, tag = "2")]
            pub error_message: ::prost::alloc::string::String,
        }
        /// Nested message and enum types in `FailureReason`.
        pub mod failure_reason {
            /// CorpusType for the failed crawling operation.
            #[derive(
                Clone,
                Copy,
                Debug,
                PartialEq,
                Eq,
                Hash,
                PartialOrd,
                Ord,
                ::prost::Enumeration
            )]
            #[repr(i32)]
            pub enum CorpusType {
                /// Default value.
                Unspecified = 0,
                /// Denotes a crawling attempt for the desktop version of a page.
                Desktop = 1,
                /// Denotes a crawling attempt for the mobile version of a page.
                Mobile = 2,
            }
            impl CorpusType {
                /// 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 {
                        CorpusType::Unspecified => "CORPUS_TYPE_UNSPECIFIED",
                        CorpusType::Desktop => "DESKTOP",
                        CorpusType::Mobile => "MOBILE",
                    }
                }
                /// Creates an enum from field names used in the ProtoBuf definition.
                pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                    match value {
                        "CORPUS_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                        "DESKTOP" => Some(Self::Desktop),
                        "MOBILE" => Some(Self::Mobile),
                        _ => None,
                    }
                }
            }
        }
    }
}
/// Metadata related to the progress of the
/// [SiteSearchEngineService.RecrawlUris][google.cloud.discoveryengine.v1alpha.SiteSearchEngineService.RecrawlUris]
/// operation. This will be returned by the google.longrunning.Operation.metadata
/// field.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RecrawlUrisMetadata {
    /// Operation create time.
    #[prost(message, optional, tag = "1")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Operation last update time. If the operation is done, this is also the
    /// finish time.
    #[prost(message, optional, tag = "2")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Unique URIs in the request that don't match any TargetSite in the
    /// DataStore, only match TargetSites that haven't been fully indexed, or match
    /// a TargetSite with type EXCLUDE.
    #[prost(string, repeated, tag = "3")]
    pub invalid_uris: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Total number of unique URIs in the request that are not in invalid_uris.
    #[prost(int32, tag = "4")]
    pub valid_uris_count: i32,
    /// Total number of URIs that have been crawled so far.
    #[prost(int32, tag = "5")]
    pub success_count: i32,
    /// Total number of URIs that have yet to be crawled.
    #[prost(int32, tag = "6")]
    pub pending_count: i32,
    /// Total number of URIs that were rejected due to insufficient indexing
    /// resources.
    #[prost(int32, tag = "7")]
    pub quota_exceeded_count: i32,
}
/// Request message for
/// [SiteSearchEngineService.BatchVerifyTargetSites][google.cloud.discoveryengine.v1alpha.SiteSearchEngineService.BatchVerifyTargetSites]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchVerifyTargetSitesRequest {
    /// Required. The parent resource shared by all TargetSites being verified.
    /// `projects/{project}/locations/{location}/collections/{collection}/dataStores/{data_store}/siteSearchEngine`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
}
/// Response message for
/// [SiteSearchEngineService.BatchVerifyTargetSites][google.cloud.discoveryengine.v1alpha.SiteSearchEngineService.BatchVerifyTargetSites]
/// method.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct BatchVerifyTargetSitesResponse {}
/// Metadata related to the progress of the
/// [SiteSearchEngineService.BatchVerifyTargetSites][google.cloud.discoveryengine.v1alpha.SiteSearchEngineService.BatchVerifyTargetSites]
/// operation. This will be returned by the google.longrunning.Operation.metadata
/// field.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct BatchVerifyTargetSitesMetadata {
    /// Operation create time.
    #[prost(message, optional, tag = "1")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Operation last update time. If the operation is done, this is also the
    /// finish time.
    #[prost(message, optional, tag = "2")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Request message for
/// [SiteSearchEngineService.FetchDomainVerificationStatus][google.cloud.discoveryengine.v1alpha.SiteSearchEngineService.FetchDomainVerificationStatus]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FetchDomainVerificationStatusRequest {
    /// Required. The site search engine resource under which we fetch all the
    /// domain verification status.
    /// `projects/{project}/locations/{location}/collections/{collection}/dataStores/{data_store}/siteSearchEngine`.
    #[prost(string, tag = "1")]
    pub site_search_engine: ::prost::alloc::string::String,
    /// Requested page size. Server may return fewer items than requested. If
    /// unspecified, server will pick an appropriate default. The maximum value is
    /// 1000; values above 1000 will be coerced to 1000.
    ///
    /// If this field is negative, an INVALID_ARGUMENT error is returned.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// A page token, received from a previous `FetchDomainVerificationStatus`
    /// call. Provide this to retrieve the subsequent page.
    ///
    /// When paginating, all other parameters provided to
    /// `FetchDomainVerificationStatus` must match the call that provided the page
    /// token.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// Response message for
/// [SiteSearchEngineService.FetchDomainVerificationStatus][google.cloud.discoveryengine.v1alpha.SiteSearchEngineService.FetchDomainVerificationStatus]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FetchDomainVerificationStatusResponse {
    /// List of TargetSites containing the site verification status.
    #[prost(message, repeated, tag = "1")]
    pub target_sites: ::prost::alloc::vec::Vec<TargetSite>,
    /// A token that can be sent as `page_token` to retrieve the next page.
    /// If this field is omitted, there are no subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
    /// The total number of items matching the request.
    /// This will always be populated in the response.
    #[prost(int32, tag = "3")]
    pub total_size: i32,
}
/// Request message for
/// [SiteSearchEngineService.SetUriPatternDocumentData][google.cloud.discoveryengine.v1alpha.SiteSearchEngineService.SetUriPatternDocumentData]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SetUriPatternDocumentDataRequest {
    /// Required. Full resource name of the
    /// [SiteSearchEngine][google.cloud.discoveryengine.v1alpha.SiteSearchEngine],
    /// such as
    /// `projects/*/locations/*/collections/*/dataStores/*/siteSearchEngine`.
    #[prost(string, tag = "1")]
    pub site_search_engine: ::prost::alloc::string::String,
    /// Document data keyed by URI pattern. Each entry must be consistent with
    /// the [Schema][google.cloud.discoveryengine.v1alpha.Schema]. For example:
    /// [Schema][google.cloud.discoveryengine.v1alpha.Schema] = {
    /// "type": "object",
    /// "properties": {
    ///    "Categories": {
    ///      "type": "array",
    ///      "items": {
    ///        "retrievable": true,
    ///        "type": "string"
    ///      }
    ///    }
    /// }
    ///
    /// document_data_map = {
    ///    "www.url1.com/*": {
    ///      "Categories": \["category1", "category2"\]
    ///    },
    ///    "www.url2.com/*": {
    ///      "Categories": \["category3"\]
    ///    }
    /// }
    #[prost(btree_map = "string, message", tag = "2")]
    pub document_data_map: ::prost::alloc::collections::BTreeMap<
        ::prost::alloc::string::String,
        ::prost_types::Struct,
    >,
    /// If true, clears the document data map. If true,
    /// [SetUriPatternDocumentDataRequest.document_data_map][google.cloud.discoveryengine.v1alpha.SetUriPatternDocumentDataRequest.document_data_map]
    /// must be empty.
    #[prost(bool, tag = "4")]
    pub empty_document_data_map: bool,
    /// Optional. If not provided, the current
    /// [Schema][google.cloud.discoveryengine.v1alpha.Schema] is used. If provided,
    /// validates and updates the
    /// [Schema][google.cloud.discoveryengine.v1alpha.Schema]. If validation fails,
    /// an error is returned.
    #[prost(message, optional, tag = "3")]
    pub schema: ::core::option::Option<::prost_types::Struct>,
}
/// Response message for
/// [SiteSearchEngineService.SetUriPatternDocumentData][google.cloud.discoveryengine.v1alpha.SiteSearchEngineService.SetUriPatternDocumentData]
/// method.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct SetUriPatternDocumentDataResponse {}
/// Metadata related to the progress of the
/// [SiteSearchEngineService.SetUriPatternDocumentData][google.cloud.discoveryengine.v1alpha.SiteSearchEngineService.SetUriPatternDocumentData]
/// operation. This will be returned by the google.longrunning.Operation.metadata
/// field.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct SetUriPatternDocumentDataMetadata {
    /// Operation create time.
    #[prost(message, optional, tag = "1")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Operation last update time. If the operation is done, this is also the
    /// finish time.
    #[prost(message, optional, tag = "2")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Request message for
/// [SiteSearchEngineService.GetUriPatternDocumentData][google.cloud.discoveryengine.v1alpha.SiteSearchEngineService.GetUriPatternDocumentData]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetUriPatternDocumentDataRequest {
    /// Required. Full resource name of the
    /// [SiteSearchEngine][google.cloud.discoveryengine.v1alpha.SiteSearchEngine],
    /// such as
    /// `projects/*/locations/*/collections/*/dataStores/*/siteSearchEngine`.
    #[prost(string, tag = "1")]
    pub site_search_engine: ::prost::alloc::string::String,
}
/// Response message for
/// [SiteSearchEngineService.GetUriPatternDocumentData][google.cloud.discoveryengine.v1alpha.SiteSearchEngineService.GetUriPatternDocumentData]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetUriPatternDocumentDataResponse {
    /// Document data keyed by URI pattern. For example:
    /// document_data_map = {
    ///    "www.url1.com/*": {
    ///      "Categories": \["category1", "category2"\]
    ///    },
    ///    "www.url2.com/*": {
    ///      "Categories": \["category3"\]
    ///    }
    /// }
    #[prost(btree_map = "string, message", tag = "1")]
    pub document_data_map: ::prost::alloc::collections::BTreeMap<
        ::prost::alloc::string::String,
        ::prost_types::Struct,
    >,
}
/// Generated client implementations.
pub mod site_search_engine_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for managing site search related resources.
    #[derive(Debug, Clone)]
    pub struct SiteSearchEngineServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl<T> SiteSearchEngineServiceClient<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,
        ) -> SiteSearchEngineServiceClient<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,
        {
            SiteSearchEngineServiceClient::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
        }
        /// Gets the
        /// [SiteSearchEngine][google.cloud.discoveryengine.v1alpha.SiteSearchEngine].
        pub async fn get_site_search_engine(
            &mut self,
            request: impl tonic::IntoRequest<super::GetSiteSearchEngineRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SiteSearchEngine>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.SiteSearchEngineService/GetSiteSearchEngine",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.SiteSearchEngineService",
                        "GetSiteSearchEngine",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a [TargetSite][google.cloud.discoveryengine.v1alpha.TargetSite].
        pub async fn create_target_site(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateTargetSiteRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.SiteSearchEngineService/CreateTargetSite",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.SiteSearchEngineService",
                        "CreateTargetSite",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates [TargetSite][google.cloud.discoveryengine.v1alpha.TargetSite] in a
        /// batch.
        pub async fn batch_create_target_sites(
            &mut self,
            request: impl tonic::IntoRequest<super::BatchCreateTargetSitesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.SiteSearchEngineService/BatchCreateTargetSites",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.SiteSearchEngineService",
                        "BatchCreateTargetSites",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets a [TargetSite][google.cloud.discoveryengine.v1alpha.TargetSite].
        pub async fn get_target_site(
            &mut self,
            request: impl tonic::IntoRequest<super::GetTargetSiteRequest>,
        ) -> std::result::Result<tonic::Response<super::TargetSite>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.SiteSearchEngineService/GetTargetSite",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.SiteSearchEngineService",
                        "GetTargetSite",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates a [TargetSite][google.cloud.discoveryengine.v1alpha.TargetSite].
        pub async fn update_target_site(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateTargetSiteRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.SiteSearchEngineService/UpdateTargetSite",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.SiteSearchEngineService",
                        "UpdateTargetSite",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes a [TargetSite][google.cloud.discoveryengine.v1alpha.TargetSite].
        pub async fn delete_target_site(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteTargetSiteRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.SiteSearchEngineService/DeleteTargetSite",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.SiteSearchEngineService",
                        "DeleteTargetSite",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets a list of
        /// [TargetSite][google.cloud.discoveryengine.v1alpha.TargetSite]s.
        pub async fn list_target_sites(
            &mut self,
            request: impl tonic::IntoRequest<super::ListTargetSitesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListTargetSitesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.SiteSearchEngineService/ListTargetSites",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.SiteSearchEngineService",
                        "ListTargetSites",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Upgrade from basic site search to advanced site search.
        pub async fn enable_advanced_site_search(
            &mut self,
            request: impl tonic::IntoRequest<super::EnableAdvancedSiteSearchRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.SiteSearchEngineService/EnableAdvancedSiteSearch",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.SiteSearchEngineService",
                        "EnableAdvancedSiteSearch",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Downgrade from advanced site search to basic site search.
        pub async fn disable_advanced_site_search(
            &mut self,
            request: impl tonic::IntoRequest<super::DisableAdvancedSiteSearchRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.SiteSearchEngineService/DisableAdvancedSiteSearch",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.SiteSearchEngineService",
                        "DisableAdvancedSiteSearch",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Request on-demand recrawl for a list of URIs.
        pub async fn recrawl_uris(
            &mut self,
            request: impl tonic::IntoRequest<super::RecrawlUrisRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.SiteSearchEngineService/RecrawlUris",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.SiteSearchEngineService",
                        "RecrawlUris",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Verify target sites' ownership and validity.
        /// This API sends all the target sites under site search engine for
        /// verification.
        pub async fn batch_verify_target_sites(
            &mut self,
            request: impl tonic::IntoRequest<super::BatchVerifyTargetSitesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.SiteSearchEngineService/BatchVerifyTargetSites",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.SiteSearchEngineService",
                        "BatchVerifyTargetSites",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns list of target sites with its domain verification status.
        /// This method can only be called under data store with BASIC_SITE_SEARCH
        /// state at the moment.
        pub async fn fetch_domain_verification_status(
            &mut self,
            request: impl tonic::IntoRequest<super::FetchDomainVerificationStatusRequest>,
        ) -> std::result::Result<
            tonic::Response<super::FetchDomainVerificationStatusResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.SiteSearchEngineService/FetchDomainVerificationStatus",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.SiteSearchEngineService",
                        "FetchDomainVerificationStatus",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Sets the URI Pattern to Document data mapping for an Advanced Site Search
        /// DataStore.
        pub async fn set_uri_pattern_document_data(
            &mut self,
            request: impl tonic::IntoRequest<super::SetUriPatternDocumentDataRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.SiteSearchEngineService/SetUriPatternDocumentData",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.SiteSearchEngineService",
                        "SetUriPatternDocumentData",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets the URI Pattern to Document data mapping for an Advanced Site Search
        /// DataStore.
        pub async fn get_uri_pattern_document_data(
            &mut self,
            request: impl tonic::IntoRequest<super::GetUriPatternDocumentDataRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetUriPatternDocumentDataResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.SiteSearchEngineService/GetUriPatternDocumentData",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.SiteSearchEngineService",
                        "GetUriPatternDocumentData",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Record message for
/// [RankService.Rank][google.cloud.discoveryengine.v1alpha.RankService.Rank]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RankingRecord {
    /// The unique ID to represent the record.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// The title of the record. Empty by default.
    /// At least one of
    /// [title][google.cloud.discoveryengine.v1alpha.RankingRecord.title] or
    /// [content][google.cloud.discoveryengine.v1alpha.RankingRecord.content]
    /// should be set otherwise an INVALID_ARGUMENT error is thrown.
    #[prost(string, tag = "2")]
    pub title: ::prost::alloc::string::String,
    /// The content of the record. Empty by default.
    /// At least one of
    /// [title][google.cloud.discoveryengine.v1alpha.RankingRecord.title] or
    /// [content][google.cloud.discoveryengine.v1alpha.RankingRecord.content]
    /// should be set otherwise an INVALID_ARGUMENT error is thrown.
    #[prost(string, tag = "3")]
    pub content: ::prost::alloc::string::String,
    /// The score of this record based on the given query and selected model.
    #[prost(float, tag = "4")]
    pub score: f32,
}
/// Request message for
/// [RankService.Rank][google.cloud.discoveryengine.v1alpha.RankService.Rank]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RankRequest {
    /// Required. The resource name of the rank service config, such as
    /// `projects/{project_num}/locations/{location_id}/rankingConfigs/default_ranking_config`.
    #[prost(string, tag = "1")]
    pub ranking_config: ::prost::alloc::string::String,
    /// The identifier of the model to use. It is one of:
    ///
    /// * `semantic-ranker-512@latest`: Semantic ranking model with maxiumn input
    /// token size 512.
    ///
    /// It is set to `semantic-ranker-512@latest` by default if unspecified.
    #[prost(string, tag = "2")]
    pub model: ::prost::alloc::string::String,
    /// The number of results to return. If this is unset or no bigger than zero,
    /// returns all results.
    #[prost(int32, tag = "3")]
    pub top_n: i32,
    /// The query to use.
    #[prost(string, tag = "4")]
    pub query: ::prost::alloc::string::String,
    /// Required. A list of records to rank. At most 200 records to rank.
    #[prost(message, repeated, tag = "5")]
    pub records: ::prost::alloc::vec::Vec<RankingRecord>,
    /// If true, the response will contain only record ID and score. By default, it
    /// is false, the response will contain record details.
    #[prost(bool, tag = "6")]
    pub ignore_record_details_in_response: bool,
    /// The user labels applied to a resource must meet the following requirements:
    ///
    /// * Each resource can have multiple labels, up to a maximum of 64.
    /// * Each label must be a key-value pair.
    /// * Keys have a minimum length of 1 character and a maximum length of 63
    ///    characters and cannot be empty. Values can be empty and have a maximum
    ///    length of 63 characters.
    /// * Keys and values can contain only lowercase letters, numeric characters,
    ///    underscores, and dashes. All characters must use UTF-8 encoding, and
    ///    international characters are allowed.
    /// * The key portion of a label must be unique. However, you can use the same
    ///    key with multiple resources.
    /// * Keys must start with a lowercase letter or international character.
    ///
    /// See [Google Cloud
    /// Document](<https://cloud.google.com/resource-manager/docs/creating-managing-labels#requirements>)
    /// for more details.
    #[prost(btree_map = "string, string", tag = "7")]
    pub user_labels: ::prost::alloc::collections::BTreeMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
/// Response message for
/// [RankService.Rank][google.cloud.discoveryengine.v1alpha.RankService.Rank]
/// method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RankResponse {
    /// A list of records sorted by descending score.
    #[prost(message, repeated, tag = "5")]
    pub records: ::prost::alloc::vec::Vec<RankingRecord>,
}
/// Generated client implementations.
pub mod rank_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for ranking text records.
    #[derive(Debug, Clone)]
    pub struct RankServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl<T> RankServiceClient<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,
        ) -> RankServiceClient<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,
        {
            RankServiceClient::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
        }
        /// Ranks a list of text records based on the given input query.
        pub async fn rank(
            &mut self,
            request: impl tonic::IntoRequest<super::RankRequest>,
        ) -> std::result::Result<tonic::Response<super::RankResponse>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.discoveryengine.v1alpha.RankService/Rank",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.discoveryengine.v1alpha.RankService",
                        "Rank",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}