google_cloud_vectorsearch_v1/

model.rs

// Copyright 2026 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Code generated by sidekick. DO NOT EDIT.

#![allow(rustdoc::redundant_explicit_links)]
#![allow(rustdoc::broken_intra_doc_links)]
#![no_implicit_prelude]
extern crate async_trait;
extern crate bytes;
extern crate gaxi;
extern crate google_cloud_gax;
extern crate google_cloud_location;
extern crate google_cloud_longrunning;
extern crate google_cloud_lro;
extern crate google_cloud_rpc;
extern crate lazy_static;
extern crate serde;
extern crate serde_json;
extern crate serde_with;
extern crate std;
extern crate tracing;
extern crate wkt;

mod debug;
mod deserialize;
mod serialize;

/// A dataObject resource in Vector Search.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DataObject {
    /// Identifier. The fully qualified resource name of the dataObject.
    ///
    /// Format:
    /// `projects/{project}/locations/{location}/collections/{collection}/dataObjects/{data_object_id}`
    /// The data_object_id must be 1-63 characters
    /// long, and comply with [RFC1035](https://www.ietf.org/rfc/rfc1035.txt).
    pub name: std::string::String,

    /// Output only. The id of the dataObject.
    pub data_object_id: std::string::String,

    /// Output only. Timestamp the dataObject was created at.
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. Timestamp the dataObject was last updated.
    pub update_time: std::option::Option<wkt::Timestamp>,

    /// Optional. The data of the dataObject.
    pub data: std::option::Option<wkt::Struct>,

    /// Optional. The vectors of the dataObject.
    pub vectors: std::collections::HashMap<std::string::String, crate::model::Vector>,

    /// Optional. The etag of the dataObject.
    pub etag: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl DataObject {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::DataObject::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::DataObject;
    /// let x = DataObject::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [data_object_id][crate::model::DataObject::data_object_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::DataObject;
    /// let x = DataObject::new().set_data_object_id("example");
    /// ```
    pub fn set_data_object_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.data_object_id = v.into();
        self
    }

    /// Sets the value of [create_time][crate::model::DataObject::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::DataObject;
    /// use wkt::Timestamp;
    /// let x = DataObject::new().set_create_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_create_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.create_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [create_time][crate::model::DataObject::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::DataObject;
    /// use wkt::Timestamp;
    /// let x = DataObject::new().set_or_clear_create_time(Some(Timestamp::default()/* use setters */));
    /// let x = DataObject::new().set_or_clear_create_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_create_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.create_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [update_time][crate::model::DataObject::update_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::DataObject;
    /// use wkt::Timestamp;
    /// let x = DataObject::new().set_update_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_update_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.update_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [update_time][crate::model::DataObject::update_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::DataObject;
    /// use wkt::Timestamp;
    /// let x = DataObject::new().set_or_clear_update_time(Some(Timestamp::default()/* use setters */));
    /// let x = DataObject::new().set_or_clear_update_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_update_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.update_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [data][crate::model::DataObject::data].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::DataObject;
    /// use wkt::Struct;
    /// let x = DataObject::new().set_data(Struct::default()/* use setters */);
    /// ```
    pub fn set_data<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Struct>,
    {
        self.data = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [data][crate::model::DataObject::data].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::DataObject;
    /// use wkt::Struct;
    /// let x = DataObject::new().set_or_clear_data(Some(Struct::default()/* use setters */));
    /// let x = DataObject::new().set_or_clear_data(None::<Struct>);
    /// ```
    pub fn set_or_clear_data<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Struct>,
    {
        self.data = v.map(|x| x.into());
        self
    }

    /// Sets the value of [vectors][crate::model::DataObject::vectors].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::DataObject;
    /// use google_cloud_vectorsearch_v1::model::Vector;
    /// let x = DataObject::new().set_vectors([
    ///     ("key0", Vector::default()/* use setters */),
    ///     ("key1", Vector::default()/* use (different) setters */),
    /// ]);
    /// ```
    pub fn set_vectors<T, K, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = (K, V)>,
        K: std::convert::Into<std::string::String>,
        V: std::convert::Into<crate::model::Vector>,
    {
        use std::iter::Iterator;
        self.vectors = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }

    /// Sets the value of [etag][crate::model::DataObject::etag].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::DataObject;
    /// let x = DataObject::new().set_etag("example");
    /// ```
    pub fn set_etag<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.etag = v.into();
        self
    }
}

impl wkt::message::Message for DataObject {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.DataObject"
    }
}

/// A vector which can be either dense or sparse.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Vector {
    /// The type of the vector.
    pub vector_type: std::option::Option<crate::model::vector::VectorType>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl Vector {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [vector_type][crate::model::Vector::vector_type].
    ///
    /// Note that all the setters affecting `vector_type` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::Vector;
    /// use google_cloud_vectorsearch_v1::model::DenseVector;
    /// let x = Vector::new().set_vector_type(Some(
    ///     google_cloud_vectorsearch_v1::model::vector::VectorType::Dense(DenseVector::default().into())));
    /// ```
    pub fn set_vector_type<
        T: std::convert::Into<std::option::Option<crate::model::vector::VectorType>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.vector_type = v.into();
        self
    }

    /// The value of [vector_type][crate::model::Vector::vector_type]
    /// if it holds a `Dense`, `None` if the field is not set or
    /// holds a different branch.
    pub fn dense(&self) -> std::option::Option<&std::boxed::Box<crate::model::DenseVector>> {
        #[allow(unreachable_patterns)]
        self.vector_type.as_ref().and_then(|v| match v {
            crate::model::vector::VectorType::Dense(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [vector_type][crate::model::Vector::vector_type]
    /// to hold a `Dense`.
    ///
    /// Note that all the setters affecting `vector_type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::Vector;
    /// use google_cloud_vectorsearch_v1::model::DenseVector;
    /// let x = Vector::new().set_dense(DenseVector::default()/* use setters */);
    /// assert!(x.dense().is_some());
    /// assert!(x.sparse().is_none());
    /// ```
    pub fn set_dense<T: std::convert::Into<std::boxed::Box<crate::model::DenseVector>>>(
        mut self,
        v: T,
    ) -> Self {
        self.vector_type =
            std::option::Option::Some(crate::model::vector::VectorType::Dense(v.into()));
        self
    }

    /// The value of [vector_type][crate::model::Vector::vector_type]
    /// if it holds a `Sparse`, `None` if the field is not set or
    /// holds a different branch.
    pub fn sparse(&self) -> std::option::Option<&std::boxed::Box<crate::model::SparseVector>> {
        #[allow(unreachable_patterns)]
        self.vector_type.as_ref().and_then(|v| match v {
            crate::model::vector::VectorType::Sparse(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [vector_type][crate::model::Vector::vector_type]
    /// to hold a `Sparse`.
    ///
    /// Note that all the setters affecting `vector_type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::Vector;
    /// use google_cloud_vectorsearch_v1::model::SparseVector;
    /// let x = Vector::new().set_sparse(SparseVector::default()/* use setters */);
    /// assert!(x.sparse().is_some());
    /// assert!(x.dense().is_none());
    /// ```
    pub fn set_sparse<T: std::convert::Into<std::boxed::Box<crate::model::SparseVector>>>(
        mut self,
        v: T,
    ) -> Self {
        self.vector_type =
            std::option::Option::Some(crate::model::vector::VectorType::Sparse(v.into()));
        self
    }
}

impl wkt::message::Message for Vector {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.Vector"
    }
}

/// Defines additional types related to [Vector].
pub mod vector {
    #[allow(unused_imports)]
    use super::*;

    /// The type of the vector.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum VectorType {
        /// A dense vector.
        Dense(std::boxed::Box<crate::model::DenseVector>),
        /// A sparse vector.
        Sparse(std::boxed::Box<crate::model::SparseVector>),
    }
}

/// A dense vector.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DenseVector {
    /// Required. The values of the vector.
    pub values: std::vec::Vec<f32>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl DenseVector {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [values][crate::model::DenseVector::values].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::DenseVector;
    /// let x = DenseVector::new().set_values([1.0, 2.0, 3.0]);
    /// ```
    pub fn set_values<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<f32>,
    {
        use std::iter::Iterator;
        self.values = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for DenseVector {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.DenseVector"
    }
}

/// A sparse vector.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SparseVector {
    /// Required. The values of the vector.
    pub values: std::vec::Vec<f32>,

    /// Required. The corresponding indices for the values.
    pub indices: std::vec::Vec<i32>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SparseVector {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [values][crate::model::SparseVector::values].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::SparseVector;
    /// let x = SparseVector::new().set_values([1.0, 2.0, 3.0]);
    /// ```
    pub fn set_values<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<f32>,
    {
        use std::iter::Iterator;
        self.values = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [indices][crate::model::SparseVector::indices].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::SparseVector;
    /// let x = SparseVector::new().set_indices([1, 2, 3]);
    /// ```
    pub fn set_indices<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<i32>,
    {
        use std::iter::Iterator;
        self.indices = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for SparseVector {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.SparseVector"
    }
}

/// Defines a output fields struct for data in DataObject.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct OutputFields {
    /// Optional. The fields from the data fields to include in the output.
    pub data_fields: std::vec::Vec<std::string::String>,

    /// Optional. The fields from the vector fields to include in the output.
    pub vector_fields: std::vec::Vec<std::string::String>,

    /// Optional. The fields from the DataObject metadata to include in the output.
    pub metadata_fields: std::vec::Vec<std::string::String>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl OutputFields {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [data_fields][crate::model::OutputFields::data_fields].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::OutputFields;
    /// let x = OutputFields::new().set_data_fields(["a", "b", "c"]);
    /// ```
    pub fn set_data_fields<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.data_fields = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [vector_fields][crate::model::OutputFields::vector_fields].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::OutputFields;
    /// let x = OutputFields::new().set_vector_fields(["a", "b", "c"]);
    /// ```
    pub fn set_vector_fields<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.vector_fields = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [metadata_fields][crate::model::OutputFields::metadata_fields].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::OutputFields;
    /// let x = OutputFields::new().set_metadata_fields(["a", "b", "c"]);
    /// ```
    pub fn set_metadata_fields<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.metadata_fields = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for OutputFields {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.OutputFields"
    }
}

/// Represents a hint to the search index engine.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SearchHint {
    /// The type of index to use.
    pub index_type: std::option::Option<crate::model::search_hint::IndexType>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SearchHint {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [index_type][crate::model::SearchHint::index_type].
    ///
    /// Note that all the setters affecting `index_type` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::SearchHint;
    /// use google_cloud_vectorsearch_v1::model::search_hint::KnnHint;
    /// let x = SearchHint::new().set_index_type(Some(
    ///     google_cloud_vectorsearch_v1::model::search_hint::IndexType::KnnHint(KnnHint::default().into())));
    /// ```
    pub fn set_index_type<
        T: std::convert::Into<std::option::Option<crate::model::search_hint::IndexType>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.index_type = v.into();
        self
    }

    /// The value of [index_type][crate::model::SearchHint::index_type]
    /// if it holds a `KnnHint`, `None` if the field is not set or
    /// holds a different branch.
    pub fn knn_hint(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::search_hint::KnnHint>> {
        #[allow(unreachable_patterns)]
        self.index_type.as_ref().and_then(|v| match v {
            crate::model::search_hint::IndexType::KnnHint(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [index_type][crate::model::SearchHint::index_type]
    /// to hold a `KnnHint`.
    ///
    /// Note that all the setters affecting `index_type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::SearchHint;
    /// use google_cloud_vectorsearch_v1::model::search_hint::KnnHint;
    /// let x = SearchHint::new().set_knn_hint(KnnHint::default()/* use setters */);
    /// assert!(x.knn_hint().is_some());
    /// assert!(x.index_hint().is_none());
    /// ```
    pub fn set_knn_hint<
        T: std::convert::Into<std::boxed::Box<crate::model::search_hint::KnnHint>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.index_type =
            std::option::Option::Some(crate::model::search_hint::IndexType::KnnHint(v.into()));
        self
    }

    /// The value of [index_type][crate::model::SearchHint::index_type]
    /// if it holds a `IndexHint`, `None` if the field is not set or
    /// holds a different branch.
    pub fn index_hint(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::search_hint::IndexHint>> {
        #[allow(unreachable_patterns)]
        self.index_type.as_ref().and_then(|v| match v {
            crate::model::search_hint::IndexType::IndexHint(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [index_type][crate::model::SearchHint::index_type]
    /// to hold a `IndexHint`.
    ///
    /// Note that all the setters affecting `index_type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::SearchHint;
    /// use google_cloud_vectorsearch_v1::model::search_hint::IndexHint;
    /// let x = SearchHint::new().set_index_hint(IndexHint::default()/* use setters */);
    /// assert!(x.index_hint().is_some());
    /// assert!(x.knn_hint().is_none());
    /// ```
    pub fn set_index_hint<
        T: std::convert::Into<std::boxed::Box<crate::model::search_hint::IndexHint>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.index_type =
            std::option::Option::Some(crate::model::search_hint::IndexType::IndexHint(v.into()));
        self
    }
}

impl wkt::message::Message for SearchHint {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.SearchHint"
    }
}

/// Defines additional types related to [SearchHint].
pub mod search_hint {
    #[allow(unused_imports)]
    use super::*;

    /// Message to specify the index to use for the search.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct IndexHint {
        /// Required. The resource name of the index to use for the search.
        /// The index must be in the same project, location, and collection.
        /// Format:
        /// `projects/{project}/locations/{location}/collections/{collection}/indexes/{index}`
        pub name: std::string::String,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl IndexHint {
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [name][crate::model::search_hint::IndexHint::name].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_vectorsearch_v1::model::search_hint::IndexHint;
        /// let x = IndexHint::new().set_name("example");
        /// ```
        pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.name = v.into();
            self
        }
    }

    impl wkt::message::Message for IndexHint {
        fn typename() -> &'static str {
            "type.googleapis.com/google.cloud.vectorsearch.v1.SearchHint.IndexHint"
        }
    }

    /// KnnHint will be used if search should be explicitly done on system's
    /// default K-Nearest Neighbor (KNN) index engine.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct KnnHint {
        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl KnnHint {
        pub fn new() -> Self {
            std::default::Default::default()
        }
    }

    impl wkt::message::Message for KnnHint {
        fn typename() -> &'static str {
            "type.googleapis.com/google.cloud.vectorsearch.v1.SearchHint.KnnHint"
        }
    }

    /// The type of index to use.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum IndexType {
        /// Optional. If set, the search will use the system's default
        /// K-Nearest Neighbor (KNN) index engine.
        KnnHint(std::boxed::Box<crate::model::search_hint::KnnHint>),
        /// Optional. Specifies that the search should use a particular index.
        IndexHint(std::boxed::Box<crate::model::search_hint::IndexHint>),
    }
}

/// A single search request within a batch operation.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Search {
    /// The type of search to perform.
    pub search_type: std::option::Option<crate::model::search::SearchType>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl Search {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [search_type][crate::model::Search::search_type].
    ///
    /// Note that all the setters affecting `search_type` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::Search;
    /// use google_cloud_vectorsearch_v1::model::VectorSearch;
    /// let x = Search::new().set_search_type(Some(
    ///     google_cloud_vectorsearch_v1::model::search::SearchType::VectorSearch(VectorSearch::default().into())));
    /// ```
    pub fn set_search_type<
        T: std::convert::Into<std::option::Option<crate::model::search::SearchType>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.search_type = v.into();
        self
    }

    /// The value of [search_type][crate::model::Search::search_type]
    /// if it holds a `VectorSearch`, `None` if the field is not set or
    /// holds a different branch.
    pub fn vector_search(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::VectorSearch>> {
        #[allow(unreachable_patterns)]
        self.search_type.as_ref().and_then(|v| match v {
            crate::model::search::SearchType::VectorSearch(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [search_type][crate::model::Search::search_type]
    /// to hold a `VectorSearch`.
    ///
    /// Note that all the setters affecting `search_type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::Search;
    /// use google_cloud_vectorsearch_v1::model::VectorSearch;
    /// let x = Search::new().set_vector_search(VectorSearch::default()/* use setters */);
    /// assert!(x.vector_search().is_some());
    /// assert!(x.semantic_search().is_none());
    /// assert!(x.text_search().is_none());
    /// ```
    pub fn set_vector_search<T: std::convert::Into<std::boxed::Box<crate::model::VectorSearch>>>(
        mut self,
        v: T,
    ) -> Self {
        self.search_type =
            std::option::Option::Some(crate::model::search::SearchType::VectorSearch(v.into()));
        self
    }

    /// The value of [search_type][crate::model::Search::search_type]
    /// if it holds a `SemanticSearch`, `None` if the field is not set or
    /// holds a different branch.
    pub fn semantic_search(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::SemanticSearch>> {
        #[allow(unreachable_patterns)]
        self.search_type.as_ref().and_then(|v| match v {
            crate::model::search::SearchType::SemanticSearch(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [search_type][crate::model::Search::search_type]
    /// to hold a `SemanticSearch`.
    ///
    /// Note that all the setters affecting `search_type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::Search;
    /// use google_cloud_vectorsearch_v1::model::SemanticSearch;
    /// let x = Search::new().set_semantic_search(SemanticSearch::default()/* use setters */);
    /// assert!(x.semantic_search().is_some());
    /// assert!(x.vector_search().is_none());
    /// assert!(x.text_search().is_none());
    /// ```
    pub fn set_semantic_search<
        T: std::convert::Into<std::boxed::Box<crate::model::SemanticSearch>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.search_type =
            std::option::Option::Some(crate::model::search::SearchType::SemanticSearch(v.into()));
        self
    }

    /// The value of [search_type][crate::model::Search::search_type]
    /// if it holds a `TextSearch`, `None` if the field is not set or
    /// holds a different branch.
    pub fn text_search(&self) -> std::option::Option<&std::boxed::Box<crate::model::TextSearch>> {
        #[allow(unreachable_patterns)]
        self.search_type.as_ref().and_then(|v| match v {
            crate::model::search::SearchType::TextSearch(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [search_type][crate::model::Search::search_type]
    /// to hold a `TextSearch`.
    ///
    /// Note that all the setters affecting `search_type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::Search;
    /// use google_cloud_vectorsearch_v1::model::TextSearch;
    /// let x = Search::new().set_text_search(TextSearch::default()/* use setters */);
    /// assert!(x.text_search().is_some());
    /// assert!(x.vector_search().is_none());
    /// assert!(x.semantic_search().is_none());
    /// ```
    pub fn set_text_search<T: std::convert::Into<std::boxed::Box<crate::model::TextSearch>>>(
        mut self,
        v: T,
    ) -> Self {
        self.search_type =
            std::option::Option::Some(crate::model::search::SearchType::TextSearch(v.into()));
        self
    }
}

impl wkt::message::Message for Search {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.Search"
    }
}

/// Defines additional types related to [Search].
pub mod search {
    #[allow(unused_imports)]
    use super::*;

    /// The type of search to perform.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum SearchType {
        /// A vector-based search.
        VectorSearch(std::boxed::Box<crate::model::VectorSearch>),
        /// A semantic search.
        SemanticSearch(std::boxed::Box<crate::model::SemanticSearch>),
        /// A text search operation.
        TextSearch(std::boxed::Box<crate::model::TextSearch>),
    }
}

/// Defines a search operation using a query vector.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct VectorSearch {
    /// Required. The vector field to search.
    pub search_field: std::string::String,

    /// Optional. A JSON filter expression, e.g. {"genre": {"$eq": "sci-fi"}},
    /// represented as a google.protobuf.Struct.
    pub filter: std::option::Option<wkt::Struct>,

    /// Optional. The number of nearest neighbors to return.
    pub top_k: std::option::Option<i32>,

    /// Optional. Mask specifying which fields to return.
    pub output_fields: std::option::Option<crate::model::OutputFields>,

    /// Optional. Sets the search hint. If no strategy is specified, the service
    /// will use an index if one is available, and fall back to the default KNN
    /// search otherwise.
    pub search_hint: std::option::Option<crate::model::SearchHint>,

    /// Optional. The distance metric to use for the KNN search. If not specified,
    /// DOT_PRODUCT will be used as the default.
    pub distance_metric: crate::model::DistanceMetric,

    pub vector_type: std::option::Option<crate::model::vector_search::VectorType>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl VectorSearch {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [search_field][crate::model::VectorSearch::search_field].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::VectorSearch;
    /// let x = VectorSearch::new().set_search_field("example");
    /// ```
    pub fn set_search_field<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.search_field = v.into();
        self
    }

    /// Sets the value of [filter][crate::model::VectorSearch::filter].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::VectorSearch;
    /// use wkt::Struct;
    /// let x = VectorSearch::new().set_filter(Struct::default()/* use setters */);
    /// ```
    pub fn set_filter<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Struct>,
    {
        self.filter = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [filter][crate::model::VectorSearch::filter].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::VectorSearch;
    /// use wkt::Struct;
    /// let x = VectorSearch::new().set_or_clear_filter(Some(Struct::default()/* use setters */));
    /// let x = VectorSearch::new().set_or_clear_filter(None::<Struct>);
    /// ```
    pub fn set_or_clear_filter<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Struct>,
    {
        self.filter = v.map(|x| x.into());
        self
    }

    /// Sets the value of [top_k][crate::model::VectorSearch::top_k].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::VectorSearch;
    /// let x = VectorSearch::new().set_top_k(42);
    /// ```
    pub fn set_top_k<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<i32>,
    {
        self.top_k = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [top_k][crate::model::VectorSearch::top_k].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::VectorSearch;
    /// let x = VectorSearch::new().set_or_clear_top_k(Some(42));
    /// let x = VectorSearch::new().set_or_clear_top_k(None::<i32>);
    /// ```
    pub fn set_or_clear_top_k<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<i32>,
    {
        self.top_k = v.map(|x| x.into());
        self
    }

    /// Sets the value of [output_fields][crate::model::VectorSearch::output_fields].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::VectorSearch;
    /// use google_cloud_vectorsearch_v1::model::OutputFields;
    /// let x = VectorSearch::new().set_output_fields(OutputFields::default()/* use setters */);
    /// ```
    pub fn set_output_fields<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::OutputFields>,
    {
        self.output_fields = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [output_fields][crate::model::VectorSearch::output_fields].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::VectorSearch;
    /// use google_cloud_vectorsearch_v1::model::OutputFields;
    /// let x = VectorSearch::new().set_or_clear_output_fields(Some(OutputFields::default()/* use setters */));
    /// let x = VectorSearch::new().set_or_clear_output_fields(None::<OutputFields>);
    /// ```
    pub fn set_or_clear_output_fields<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::OutputFields>,
    {
        self.output_fields = v.map(|x| x.into());
        self
    }

    /// Sets the value of [search_hint][crate::model::VectorSearch::search_hint].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::VectorSearch;
    /// use google_cloud_vectorsearch_v1::model::SearchHint;
    /// let x = VectorSearch::new().set_search_hint(SearchHint::default()/* use setters */);
    /// ```
    pub fn set_search_hint<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::SearchHint>,
    {
        self.search_hint = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [search_hint][crate::model::VectorSearch::search_hint].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::VectorSearch;
    /// use google_cloud_vectorsearch_v1::model::SearchHint;
    /// let x = VectorSearch::new().set_or_clear_search_hint(Some(SearchHint::default()/* use setters */));
    /// let x = VectorSearch::new().set_or_clear_search_hint(None::<SearchHint>);
    /// ```
    pub fn set_or_clear_search_hint<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::SearchHint>,
    {
        self.search_hint = v.map(|x| x.into());
        self
    }

    /// Sets the value of [distance_metric][crate::model::VectorSearch::distance_metric].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::VectorSearch;
    /// use google_cloud_vectorsearch_v1::model::DistanceMetric;
    /// let x0 = VectorSearch::new().set_distance_metric(DistanceMetric::DotProduct);
    /// let x1 = VectorSearch::new().set_distance_metric(DistanceMetric::CosineDistance);
    /// ```
    pub fn set_distance_metric<T: std::convert::Into<crate::model::DistanceMetric>>(
        mut self,
        v: T,
    ) -> Self {
        self.distance_metric = v.into();
        self
    }

    /// Sets the value of [vector_type][crate::model::VectorSearch::vector_type].
    ///
    /// Note that all the setters affecting `vector_type` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::VectorSearch;
    /// use google_cloud_vectorsearch_v1::model::DenseVector;
    /// let x = VectorSearch::new().set_vector_type(Some(
    ///     google_cloud_vectorsearch_v1::model::vector_search::VectorType::Vector(DenseVector::default().into())));
    /// ```
    pub fn set_vector_type<
        T: std::convert::Into<std::option::Option<crate::model::vector_search::VectorType>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.vector_type = v.into();
        self
    }

    /// The value of [vector_type][crate::model::VectorSearch::vector_type]
    /// if it holds a `Vector`, `None` if the field is not set or
    /// holds a different branch.
    pub fn vector(&self) -> std::option::Option<&std::boxed::Box<crate::model::DenseVector>> {
        #[allow(unreachable_patterns)]
        self.vector_type.as_ref().and_then(|v| match v {
            crate::model::vector_search::VectorType::Vector(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [vector_type][crate::model::VectorSearch::vector_type]
    /// to hold a `Vector`.
    ///
    /// Note that all the setters affecting `vector_type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::VectorSearch;
    /// use google_cloud_vectorsearch_v1::model::DenseVector;
    /// let x = VectorSearch::new().set_vector(DenseVector::default()/* use setters */);
    /// assert!(x.vector().is_some());
    /// assert!(x.sparse_vector().is_none());
    /// ```
    pub fn set_vector<T: std::convert::Into<std::boxed::Box<crate::model::DenseVector>>>(
        mut self,
        v: T,
    ) -> Self {
        self.vector_type =
            std::option::Option::Some(crate::model::vector_search::VectorType::Vector(v.into()));
        self
    }

    /// The value of [vector_type][crate::model::VectorSearch::vector_type]
    /// if it holds a `SparseVector`, `None` if the field is not set or
    /// holds a different branch.
    pub fn sparse_vector(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::SparseVector>> {
        #[allow(unreachable_patterns)]
        self.vector_type.as_ref().and_then(|v| match v {
            crate::model::vector_search::VectorType::SparseVector(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [vector_type][crate::model::VectorSearch::vector_type]
    /// to hold a `SparseVector`.
    ///
    /// Note that all the setters affecting `vector_type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::VectorSearch;
    /// use google_cloud_vectorsearch_v1::model::SparseVector;
    /// let x = VectorSearch::new().set_sparse_vector(SparseVector::default()/* use setters */);
    /// assert!(x.sparse_vector().is_some());
    /// assert!(x.vector().is_none());
    /// ```
    pub fn set_sparse_vector<T: std::convert::Into<std::boxed::Box<crate::model::SparseVector>>>(
        mut self,
        v: T,
    ) -> Self {
        self.vector_type = std::option::Option::Some(
            crate::model::vector_search::VectorType::SparseVector(v.into()),
        );
        self
    }
}

impl wkt::message::Message for VectorSearch {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.VectorSearch"
    }
}

/// Defines additional types related to [VectorSearch].
pub mod vector_search {
    #[allow(unused_imports)]
    use super::*;

    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum VectorType {
        /// A dense vector for the query.
        Vector(std::boxed::Box<crate::model::DenseVector>),
        /// A sparse vector for the query.
        SparseVector(std::boxed::Box<crate::model::SparseVector>),
    }
}

/// Defines a semantic search operation.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SemanticSearch {
    /// Required. The query text, which is used to generate an embedding according
    /// to the embedding model specified in the collection config.
    pub search_text: std::string::String,

    /// Required. The vector field to search.
    pub search_field: std::string::String,

    /// Required. The task type of the query embedding.
    pub task_type: crate::model::EmbeddingTaskType,

    /// Optional. The fields to return in the search results.
    pub output_fields: std::option::Option<crate::model::OutputFields>,

    /// Optional. A JSON filter expression, e.g. {"genre": {"$eq": "sci-fi"}},
    /// represented as a google.protobuf.Struct.
    pub filter: std::option::Option<wkt::Struct>,

    /// Optional. The number of data objects to return.
    pub top_k: std::option::Option<i32>,

    /// Optional. Sets the search hint. If no strategy is specified, the service
    /// will use an index if one is available, and fall back to KNN search
    /// otherwise.
    pub search_hint: std::option::Option<crate::model::SearchHint>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SemanticSearch {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [search_text][crate::model::SemanticSearch::search_text].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::SemanticSearch;
    /// let x = SemanticSearch::new().set_search_text("example");
    /// ```
    pub fn set_search_text<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.search_text = v.into();
        self
    }

    /// Sets the value of [search_field][crate::model::SemanticSearch::search_field].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::SemanticSearch;
    /// let x = SemanticSearch::new().set_search_field("example");
    /// ```
    pub fn set_search_field<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.search_field = v.into();
        self
    }

    /// Sets the value of [task_type][crate::model::SemanticSearch::task_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::SemanticSearch;
    /// use google_cloud_vectorsearch_v1::model::EmbeddingTaskType;
    /// let x0 = SemanticSearch::new().set_task_type(EmbeddingTaskType::RetrievalQuery);
    /// let x1 = SemanticSearch::new().set_task_type(EmbeddingTaskType::RetrievalDocument);
    /// let x2 = SemanticSearch::new().set_task_type(EmbeddingTaskType::SemanticSimilarity);
    /// ```
    pub fn set_task_type<T: std::convert::Into<crate::model::EmbeddingTaskType>>(
        mut self,
        v: T,
    ) -> Self {
        self.task_type = v.into();
        self
    }

    /// Sets the value of [output_fields][crate::model::SemanticSearch::output_fields].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::SemanticSearch;
    /// use google_cloud_vectorsearch_v1::model::OutputFields;
    /// let x = SemanticSearch::new().set_output_fields(OutputFields::default()/* use setters */);
    /// ```
    pub fn set_output_fields<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::OutputFields>,
    {
        self.output_fields = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [output_fields][crate::model::SemanticSearch::output_fields].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::SemanticSearch;
    /// use google_cloud_vectorsearch_v1::model::OutputFields;
    /// let x = SemanticSearch::new().set_or_clear_output_fields(Some(OutputFields::default()/* use setters */));
    /// let x = SemanticSearch::new().set_or_clear_output_fields(None::<OutputFields>);
    /// ```
    pub fn set_or_clear_output_fields<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::OutputFields>,
    {
        self.output_fields = v.map(|x| x.into());
        self
    }

    /// Sets the value of [filter][crate::model::SemanticSearch::filter].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::SemanticSearch;
    /// use wkt::Struct;
    /// let x = SemanticSearch::new().set_filter(Struct::default()/* use setters */);
    /// ```
    pub fn set_filter<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Struct>,
    {
        self.filter = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [filter][crate::model::SemanticSearch::filter].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::SemanticSearch;
    /// use wkt::Struct;
    /// let x = SemanticSearch::new().set_or_clear_filter(Some(Struct::default()/* use setters */));
    /// let x = SemanticSearch::new().set_or_clear_filter(None::<Struct>);
    /// ```
    pub fn set_or_clear_filter<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Struct>,
    {
        self.filter = v.map(|x| x.into());
        self
    }

    /// Sets the value of [top_k][crate::model::SemanticSearch::top_k].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::SemanticSearch;
    /// let x = SemanticSearch::new().set_top_k(42);
    /// ```
    pub fn set_top_k<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<i32>,
    {
        self.top_k = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [top_k][crate::model::SemanticSearch::top_k].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::SemanticSearch;
    /// let x = SemanticSearch::new().set_or_clear_top_k(Some(42));
    /// let x = SemanticSearch::new().set_or_clear_top_k(None::<i32>);
    /// ```
    pub fn set_or_clear_top_k<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<i32>,
    {
        self.top_k = v.map(|x| x.into());
        self
    }

    /// Sets the value of [search_hint][crate::model::SemanticSearch::search_hint].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::SemanticSearch;
    /// use google_cloud_vectorsearch_v1::model::SearchHint;
    /// let x = SemanticSearch::new().set_search_hint(SearchHint::default()/* use setters */);
    /// ```
    pub fn set_search_hint<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::SearchHint>,
    {
        self.search_hint = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [search_hint][crate::model::SemanticSearch::search_hint].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::SemanticSearch;
    /// use google_cloud_vectorsearch_v1::model::SearchHint;
    /// let x = SemanticSearch::new().set_or_clear_search_hint(Some(SearchHint::default()/* use setters */));
    /// let x = SemanticSearch::new().set_or_clear_search_hint(None::<SearchHint>);
    /// ```
    pub fn set_or_clear_search_hint<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::SearchHint>,
    {
        self.search_hint = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for SemanticSearch {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.SemanticSearch"
    }
}

/// Defines a text search operation.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct TextSearch {
    /// Required. The query text.
    pub search_text: std::string::String,

    /// Required. The data field names to search.
    pub data_field_names: std::vec::Vec<std::string::String>,

    /// Optional. The fields to return in the search results.
    pub output_fields: std::option::Option<crate::model::OutputFields>,

    /// Optional. The number of results to return.
    pub top_k: std::option::Option<i32>,

    /// Optional. A JSON filter expression, e.g. `{"genre": {"$eq": "sci-fi"}}`,
    /// represented as a `google.protobuf.Struct`.
    pub filter: std::option::Option<wkt::Struct>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl TextSearch {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [search_text][crate::model::TextSearch::search_text].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::TextSearch;
    /// let x = TextSearch::new().set_search_text("example");
    /// ```
    pub fn set_search_text<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.search_text = v.into();
        self
    }

    /// Sets the value of [data_field_names][crate::model::TextSearch::data_field_names].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::TextSearch;
    /// let x = TextSearch::new().set_data_field_names(["a", "b", "c"]);
    /// ```
    pub fn set_data_field_names<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.data_field_names = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [output_fields][crate::model::TextSearch::output_fields].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::TextSearch;
    /// use google_cloud_vectorsearch_v1::model::OutputFields;
    /// let x = TextSearch::new().set_output_fields(OutputFields::default()/* use setters */);
    /// ```
    pub fn set_output_fields<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::OutputFields>,
    {
        self.output_fields = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [output_fields][crate::model::TextSearch::output_fields].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::TextSearch;
    /// use google_cloud_vectorsearch_v1::model::OutputFields;
    /// let x = TextSearch::new().set_or_clear_output_fields(Some(OutputFields::default()/* use setters */));
    /// let x = TextSearch::new().set_or_clear_output_fields(None::<OutputFields>);
    /// ```
    pub fn set_or_clear_output_fields<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::OutputFields>,
    {
        self.output_fields = v.map(|x| x.into());
        self
    }

    /// Sets the value of [top_k][crate::model::TextSearch::top_k].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::TextSearch;
    /// let x = TextSearch::new().set_top_k(42);
    /// ```
    pub fn set_top_k<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<i32>,
    {
        self.top_k = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [top_k][crate::model::TextSearch::top_k].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::TextSearch;
    /// let x = TextSearch::new().set_or_clear_top_k(Some(42));
    /// let x = TextSearch::new().set_or_clear_top_k(None::<i32>);
    /// ```
    pub fn set_or_clear_top_k<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<i32>,
    {
        self.top_k = v.map(|x| x.into());
        self
    }

    /// Sets the value of [filter][crate::model::TextSearch::filter].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::TextSearch;
    /// use wkt::Struct;
    /// let x = TextSearch::new().set_filter(Struct::default()/* use setters */);
    /// ```
    pub fn set_filter<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Struct>,
    {
        self.filter = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [filter][crate::model::TextSearch::filter].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::TextSearch;
    /// use wkt::Struct;
    /// let x = TextSearch::new().set_or_clear_filter(Some(Struct::default()/* use setters */));
    /// let x = TextSearch::new().set_or_clear_filter(None::<Struct>);
    /// ```
    pub fn set_or_clear_filter<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Struct>,
    {
        self.filter = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for TextSearch {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.TextSearch"
    }
}

/// Request for performing a single search.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SearchDataObjectsRequest {
    /// Required. The resource name of the Collection for which to search.
    /// Format: `projects/{project}/locations/{location}/collections/{collection}`
    pub parent: std::string::String,

    /// Optional. The standard list page size. Only supported for KNN. If not set,
    /// up to search_type.top_k results will be returned. The maximum value is
    /// 1000; values above 1000 will be coerced to 1000.
    pub page_size: i32,

    /// Optional. The standard list page token.
    /// Typically obtained via
    /// [SearchDataObjectsResponse.next_page_token][google.cloud.vectorsearch.v1.SearchDataObjectsResponse.next_page_token]
    /// of the previous
    /// [DataObjectSearchService.SearchDataObjects][google.cloud.vectorsearch.v1.DataObjectSearchService.SearchDataObjects]
    /// call.
    ///
    /// [google.cloud.vectorsearch.v1.DataObjectSearchService.SearchDataObjects]: crate::client::DataObjectSearchService::search_data_objects
    /// [google.cloud.vectorsearch.v1.SearchDataObjectsResponse.next_page_token]: crate::model::SearchDataObjectsResponse::next_page_token
    pub page_token: std::string::String,

    /// The query to search for.
    pub search_type: std::option::Option<crate::model::search_data_objects_request::SearchType>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SearchDataObjectsRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::SearchDataObjectsRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::SearchDataObjectsRequest;
    /// let x = SearchDataObjectsRequest::new().set_parent("example");
    /// ```
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [page_size][crate::model::SearchDataObjectsRequest::page_size].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::SearchDataObjectsRequest;
    /// let x = SearchDataObjectsRequest::new().set_page_size(42);
    /// ```
    pub fn set_page_size<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.page_size = v.into();
        self
    }

    /// Sets the value of [page_token][crate::model::SearchDataObjectsRequest::page_token].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::SearchDataObjectsRequest;
    /// let x = SearchDataObjectsRequest::new().set_page_token("example");
    /// ```
    pub fn set_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.page_token = v.into();
        self
    }

    /// Sets the value of [search_type][crate::model::SearchDataObjectsRequest::search_type].
    ///
    /// Note that all the setters affecting `search_type` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::SearchDataObjectsRequest;
    /// use google_cloud_vectorsearch_v1::model::VectorSearch;
    /// let x = SearchDataObjectsRequest::new().set_search_type(Some(
    ///     google_cloud_vectorsearch_v1::model::search_data_objects_request::SearchType::VectorSearch(VectorSearch::default().into())));
    /// ```
    pub fn set_search_type<
        T: std::convert::Into<
                std::option::Option<crate::model::search_data_objects_request::SearchType>,
            >,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.search_type = v.into();
        self
    }

    /// The value of [search_type][crate::model::SearchDataObjectsRequest::search_type]
    /// if it holds a `VectorSearch`, `None` if the field is not set or
    /// holds a different branch.
    pub fn vector_search(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::VectorSearch>> {
        #[allow(unreachable_patterns)]
        self.search_type.as_ref().and_then(|v| match v {
            crate::model::search_data_objects_request::SearchType::VectorSearch(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [search_type][crate::model::SearchDataObjectsRequest::search_type]
    /// to hold a `VectorSearch`.
    ///
    /// Note that all the setters affecting `search_type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::SearchDataObjectsRequest;
    /// use google_cloud_vectorsearch_v1::model::VectorSearch;
    /// let x = SearchDataObjectsRequest::new().set_vector_search(VectorSearch::default()/* use setters */);
    /// assert!(x.vector_search().is_some());
    /// assert!(x.semantic_search().is_none());
    /// assert!(x.text_search().is_none());
    /// ```
    pub fn set_vector_search<T: std::convert::Into<std::boxed::Box<crate::model::VectorSearch>>>(
        mut self,
        v: T,
    ) -> Self {
        self.search_type = std::option::Option::Some(
            crate::model::search_data_objects_request::SearchType::VectorSearch(v.into()),
        );
        self
    }

    /// The value of [search_type][crate::model::SearchDataObjectsRequest::search_type]
    /// if it holds a `SemanticSearch`, `None` if the field is not set or
    /// holds a different branch.
    pub fn semantic_search(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::SemanticSearch>> {
        #[allow(unreachable_patterns)]
        self.search_type.as_ref().and_then(|v| match v {
            crate::model::search_data_objects_request::SearchType::SemanticSearch(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [search_type][crate::model::SearchDataObjectsRequest::search_type]
    /// to hold a `SemanticSearch`.
    ///
    /// Note that all the setters affecting `search_type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::SearchDataObjectsRequest;
    /// use google_cloud_vectorsearch_v1::model::SemanticSearch;
    /// let x = SearchDataObjectsRequest::new().set_semantic_search(SemanticSearch::default()/* use setters */);
    /// assert!(x.semantic_search().is_some());
    /// assert!(x.vector_search().is_none());
    /// assert!(x.text_search().is_none());
    /// ```
    pub fn set_semantic_search<
        T: std::convert::Into<std::boxed::Box<crate::model::SemanticSearch>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.search_type = std::option::Option::Some(
            crate::model::search_data_objects_request::SearchType::SemanticSearch(v.into()),
        );
        self
    }

    /// The value of [search_type][crate::model::SearchDataObjectsRequest::search_type]
    /// if it holds a `TextSearch`, `None` if the field is not set or
    /// holds a different branch.
    pub fn text_search(&self) -> std::option::Option<&std::boxed::Box<crate::model::TextSearch>> {
        #[allow(unreachable_patterns)]
        self.search_type.as_ref().and_then(|v| match v {
            crate::model::search_data_objects_request::SearchType::TextSearch(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [search_type][crate::model::SearchDataObjectsRequest::search_type]
    /// to hold a `TextSearch`.
    ///
    /// Note that all the setters affecting `search_type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::SearchDataObjectsRequest;
    /// use google_cloud_vectorsearch_v1::model::TextSearch;
    /// let x = SearchDataObjectsRequest::new().set_text_search(TextSearch::default()/* use setters */);
    /// assert!(x.text_search().is_some());
    /// assert!(x.vector_search().is_none());
    /// assert!(x.semantic_search().is_none());
    /// ```
    pub fn set_text_search<T: std::convert::Into<std::boxed::Box<crate::model::TextSearch>>>(
        mut self,
        v: T,
    ) -> Self {
        self.search_type = std::option::Option::Some(
            crate::model::search_data_objects_request::SearchType::TextSearch(v.into()),
        );
        self
    }
}

impl wkt::message::Message for SearchDataObjectsRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.SearchDataObjectsRequest"
    }
}

/// Defines additional types related to [SearchDataObjectsRequest].
pub mod search_data_objects_request {
    #[allow(unused_imports)]
    use super::*;

    /// The query to search for.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum SearchType {
        /// A vector search operation.
        VectorSearch(std::boxed::Box<crate::model::VectorSearch>),
        /// A semantic search operation.
        SemanticSearch(std::boxed::Box<crate::model::SemanticSearch>),
        /// Optional. A text search operation.
        TextSearch(std::boxed::Box<crate::model::TextSearch>),
    }
}

/// A single search result.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SearchResult {
    /// Output only. The matching data object.
    pub data_object: std::option::Option<crate::model::DataObject>,

    /// Output only. Similarity distance or ranker score returned by
    /// BatchSearchDataObjects.
    pub distance: std::option::Option<f64>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SearchResult {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [data_object][crate::model::SearchResult::data_object].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::SearchResult;
    /// use google_cloud_vectorsearch_v1::model::DataObject;
    /// let x = SearchResult::new().set_data_object(DataObject::default()/* use setters */);
    /// ```
    pub fn set_data_object<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::DataObject>,
    {
        self.data_object = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [data_object][crate::model::SearchResult::data_object].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::SearchResult;
    /// use google_cloud_vectorsearch_v1::model::DataObject;
    /// let x = SearchResult::new().set_or_clear_data_object(Some(DataObject::default()/* use setters */));
    /// let x = SearchResult::new().set_or_clear_data_object(None::<DataObject>);
    /// ```
    pub fn set_or_clear_data_object<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::DataObject>,
    {
        self.data_object = v.map(|x| x.into());
        self
    }

    /// Sets the value of [distance][crate::model::SearchResult::distance].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::SearchResult;
    /// let x = SearchResult::new().set_distance(42.0);
    /// ```
    pub fn set_distance<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<f64>,
    {
        self.distance = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [distance][crate::model::SearchResult::distance].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::SearchResult;
    /// let x = SearchResult::new().set_or_clear_distance(Some(42.0));
    /// let x = SearchResult::new().set_or_clear_distance(None::<f32>);
    /// ```
    pub fn set_or_clear_distance<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<f64>,
    {
        self.distance = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for SearchResult {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.SearchResult"
    }
}

/// Response for a search request.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SearchDataObjectsResponse {
    /// Output only. The list of dataObjects that match the search criteria.
    pub results: std::vec::Vec<crate::model::SearchResult>,

    /// Output only. A token to retrieve next page of results.
    /// Pass to [DataObjectSearchService.SearchDataObjectsRequest.page_token][] to
    /// obtain that page.
    pub next_page_token: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SearchDataObjectsResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [results][crate::model::SearchDataObjectsResponse::results].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::SearchDataObjectsResponse;
    /// use google_cloud_vectorsearch_v1::model::SearchResult;
    /// let x = SearchDataObjectsResponse::new()
    ///     .set_results([
    ///         SearchResult::default()/* use setters */,
    ///         SearchResult::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_results<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::SearchResult>,
    {
        use std::iter::Iterator;
        self.results = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [next_page_token][crate::model::SearchDataObjectsResponse::next_page_token].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::SearchDataObjectsResponse;
    /// let x = SearchDataObjectsResponse::new().set_next_page_token("example");
    /// ```
    pub fn set_next_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.next_page_token = v.into();
        self
    }
}

impl wkt::message::Message for SearchDataObjectsResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.SearchDataObjectsResponse"
    }
}

#[doc(hidden)]
impl google_cloud_gax::paginator::internal::PageableResponse for SearchDataObjectsResponse {
    type PageItem = crate::model::SearchResult;

    fn items(self) -> std::vec::Vec<Self::PageItem> {
        self.results
    }

    fn next_page_token(&self) -> std::string::String {
        use std::clone::Clone;
        self.next_page_token.clone()
    }
}

/// Request message for
/// [DataObjectSearchService.AggregateDataObjects][google.cloud.vectorsearch.v1.DataObjectSearchService.AggregateDataObjects].
///
/// [google.cloud.vectorsearch.v1.DataObjectSearchService.AggregateDataObjects]: crate::client::DataObjectSearchService::aggregate_data_objects
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AggregateDataObjectsRequest {
    /// Required. The resource name of the Collection for which to query.
    /// Format: `projects/{project}/locations/{location}/collections/{collection}`
    pub parent: std::string::String,

    /// Optional. A JSON filter expression, e.g. {"genre": {"$eq": "sci-fi"}},
    /// represented as a google.protobuf.Struct.
    pub filter: std::option::Option<wkt::Struct>,

    /// Required. The aggregation method to apply to the query.
    pub aggregate: crate::model::AggregationMethod,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl AggregateDataObjectsRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::AggregateDataObjectsRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::AggregateDataObjectsRequest;
    /// let x = AggregateDataObjectsRequest::new().set_parent("example");
    /// ```
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [filter][crate::model::AggregateDataObjectsRequest::filter].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::AggregateDataObjectsRequest;
    /// use wkt::Struct;
    /// let x = AggregateDataObjectsRequest::new().set_filter(Struct::default()/* use setters */);
    /// ```
    pub fn set_filter<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Struct>,
    {
        self.filter = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [filter][crate::model::AggregateDataObjectsRequest::filter].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::AggregateDataObjectsRequest;
    /// use wkt::Struct;
    /// let x = AggregateDataObjectsRequest::new().set_or_clear_filter(Some(Struct::default()/* use setters */));
    /// let x = AggregateDataObjectsRequest::new().set_or_clear_filter(None::<Struct>);
    /// ```
    pub fn set_or_clear_filter<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Struct>,
    {
        self.filter = v.map(|x| x.into());
        self
    }

    /// Sets the value of [aggregate][crate::model::AggregateDataObjectsRequest::aggregate].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::AggregateDataObjectsRequest;
    /// use google_cloud_vectorsearch_v1::model::AggregationMethod;
    /// let x0 = AggregateDataObjectsRequest::new().set_aggregate(AggregationMethod::Count);
    /// ```
    pub fn set_aggregate<T: std::convert::Into<crate::model::AggregationMethod>>(
        mut self,
        v: T,
    ) -> Self {
        self.aggregate = v.into();
        self
    }
}

impl wkt::message::Message for AggregateDataObjectsRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.AggregateDataObjectsRequest"
    }
}

/// Response message for
/// [DataObjectSearchService.AggregateDataObjects][google.cloud.vectorsearch.v1.DataObjectSearchService.AggregateDataObjects].
///
/// [google.cloud.vectorsearch.v1.DataObjectSearchService.AggregateDataObjects]: crate::client::DataObjectSearchService::aggregate_data_objects
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AggregateDataObjectsResponse {
    /// Output only. The aggregated results of the query.
    pub aggregate_results: std::vec::Vec<wkt::Struct>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl AggregateDataObjectsResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [aggregate_results][crate::model::AggregateDataObjectsResponse::aggregate_results].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::AggregateDataObjectsResponse;
    /// use wkt::Struct;
    /// let x = AggregateDataObjectsResponse::new()
    ///     .set_aggregate_results([
    ///         Struct::default()/* use setters */,
    ///         Struct::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_aggregate_results<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<wkt::Struct>,
    {
        use std::iter::Iterator;
        self.aggregate_results = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for AggregateDataObjectsResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.AggregateDataObjectsResponse"
    }
}

/// Request message for
/// [DataObjectSearchService.QueryDataObjects][google.cloud.vectorsearch.v1.DataObjectSearchService.QueryDataObjects].
///
/// [google.cloud.vectorsearch.v1.DataObjectSearchService.QueryDataObjects]: crate::client::DataObjectSearchService::query_data_objects
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct QueryDataObjectsRequest {
    /// Required. The resource name of the Collection for which to query.
    /// Format: `projects/{project}/locations/{location}/collections/{collection}`
    pub parent: std::string::String,

    /// Optional. A JSON filter expression, e.g. {"genre": {"$eq": "sci-fi"}},
    /// represented as a google.protobuf.Struct.
    pub filter: std::option::Option<wkt::Struct>,

    /// Optional. Mask specifying which fields to return.
    pub output_fields: std::option::Option<crate::model::OutputFields>,

    /// Optional. The standard list page size. Default is 100.
    /// The maximum value is 1000; values above 1000 will be coerced to 1000.
    pub page_size: i32,

    /// Optional. The standard list page token.
    /// Typically obtained via
    /// [QueryDataObjectsResponse.next_page_token][google.cloud.vectorsearch.v1.QueryDataObjectsResponse.next_page_token]
    /// of the previous
    /// [DataObjectSearchService.QueryDataObjects][google.cloud.vectorsearch.v1.DataObjectSearchService.QueryDataObjects]
    /// call.
    ///
    /// [google.cloud.vectorsearch.v1.DataObjectSearchService.QueryDataObjects]: crate::client::DataObjectSearchService::query_data_objects
    /// [google.cloud.vectorsearch.v1.QueryDataObjectsResponse.next_page_token]: crate::model::QueryDataObjectsResponse::next_page_token
    pub page_token: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl QueryDataObjectsRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::QueryDataObjectsRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::QueryDataObjectsRequest;
    /// let x = QueryDataObjectsRequest::new().set_parent("example");
    /// ```
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [filter][crate::model::QueryDataObjectsRequest::filter].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::QueryDataObjectsRequest;
    /// use wkt::Struct;
    /// let x = QueryDataObjectsRequest::new().set_filter(Struct::default()/* use setters */);
    /// ```
    pub fn set_filter<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Struct>,
    {
        self.filter = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [filter][crate::model::QueryDataObjectsRequest::filter].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::QueryDataObjectsRequest;
    /// use wkt::Struct;
    /// let x = QueryDataObjectsRequest::new().set_or_clear_filter(Some(Struct::default()/* use setters */));
    /// let x = QueryDataObjectsRequest::new().set_or_clear_filter(None::<Struct>);
    /// ```
    pub fn set_or_clear_filter<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Struct>,
    {
        self.filter = v.map(|x| x.into());
        self
    }

    /// Sets the value of [output_fields][crate::model::QueryDataObjectsRequest::output_fields].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::QueryDataObjectsRequest;
    /// use google_cloud_vectorsearch_v1::model::OutputFields;
    /// let x = QueryDataObjectsRequest::new().set_output_fields(OutputFields::default()/* use setters */);
    /// ```
    pub fn set_output_fields<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::OutputFields>,
    {
        self.output_fields = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [output_fields][crate::model::QueryDataObjectsRequest::output_fields].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::QueryDataObjectsRequest;
    /// use google_cloud_vectorsearch_v1::model::OutputFields;
    /// let x = QueryDataObjectsRequest::new().set_or_clear_output_fields(Some(OutputFields::default()/* use setters */));
    /// let x = QueryDataObjectsRequest::new().set_or_clear_output_fields(None::<OutputFields>);
    /// ```
    pub fn set_or_clear_output_fields<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::OutputFields>,
    {
        self.output_fields = v.map(|x| x.into());
        self
    }

    /// Sets the value of [page_size][crate::model::QueryDataObjectsRequest::page_size].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::QueryDataObjectsRequest;
    /// let x = QueryDataObjectsRequest::new().set_page_size(42);
    /// ```
    pub fn set_page_size<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.page_size = v.into();
        self
    }

    /// Sets the value of [page_token][crate::model::QueryDataObjectsRequest::page_token].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::QueryDataObjectsRequest;
    /// let x = QueryDataObjectsRequest::new().set_page_token("example");
    /// ```
    pub fn set_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.page_token = v.into();
        self
    }
}

impl wkt::message::Message for QueryDataObjectsRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.QueryDataObjectsRequest"
    }
}

/// Response message for
/// [DataObjectSearchService.QueryDataObjects][google.cloud.vectorsearch.v1.DataObjectSearchService.QueryDataObjects].
///
/// [google.cloud.vectorsearch.v1.DataObjectSearchService.QueryDataObjects]: crate::client::DataObjectSearchService::query_data_objects
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct QueryDataObjectsResponse {
    /// Output only. The list of dataObjects that match the query.
    pub data_objects: std::vec::Vec<crate::model::DataObject>,

    /// Output only. A token to retrieve next page of results.
    /// Pass to [DataObjectSearchService.QueryDataObjectsRequest.page_token][] to
    /// obtain that page.
    pub next_page_token: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl QueryDataObjectsResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [data_objects][crate::model::QueryDataObjectsResponse::data_objects].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::QueryDataObjectsResponse;
    /// use google_cloud_vectorsearch_v1::model::DataObject;
    /// let x = QueryDataObjectsResponse::new()
    ///     .set_data_objects([
    ///         DataObject::default()/* use setters */,
    ///         DataObject::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_data_objects<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::DataObject>,
    {
        use std::iter::Iterator;
        self.data_objects = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [next_page_token][crate::model::QueryDataObjectsResponse::next_page_token].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::QueryDataObjectsResponse;
    /// let x = QueryDataObjectsResponse::new().set_next_page_token("example");
    /// ```
    pub fn set_next_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.next_page_token = v.into();
        self
    }
}

impl wkt::message::Message for QueryDataObjectsResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.QueryDataObjectsResponse"
    }
}

#[doc(hidden)]
impl google_cloud_gax::paginator::internal::PageableResponse for QueryDataObjectsResponse {
    type PageItem = crate::model::DataObject;

    fn items(self) -> std::vec::Vec<Self::PageItem> {
        self.data_objects
    }

    fn next_page_token(&self) -> std::string::String {
        use std::clone::Clone;
        self.next_page_token.clone()
    }
}

/// A request to perform a batch of search operations.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct BatchSearchDataObjectsRequest {
    /// Required. The resource name of the Collection for which to search.
    /// Format: `projects/{project}/locations/{location}/collections/{collection}`
    pub parent: std::string::String,

    /// Required. A list of search requests to execute in parallel.
    pub searches: std::vec::Vec<crate::model::Search>,

    /// Optional. Options for combining the results of the batch search operations.
    pub combine:
        std::option::Option<crate::model::batch_search_data_objects_request::CombineResultsOptions>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl BatchSearchDataObjectsRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::BatchSearchDataObjectsRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::BatchSearchDataObjectsRequest;
    /// let x = BatchSearchDataObjectsRequest::new().set_parent("example");
    /// ```
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [searches][crate::model::BatchSearchDataObjectsRequest::searches].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::BatchSearchDataObjectsRequest;
    /// use google_cloud_vectorsearch_v1::model::Search;
    /// let x = BatchSearchDataObjectsRequest::new()
    ///     .set_searches([
    ///         Search::default()/* use setters */,
    ///         Search::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_searches<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::Search>,
    {
        use std::iter::Iterator;
        self.searches = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [combine][crate::model::BatchSearchDataObjectsRequest::combine].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::BatchSearchDataObjectsRequest;
    /// use google_cloud_vectorsearch_v1::model::batch_search_data_objects_request::CombineResultsOptions;
    /// let x = BatchSearchDataObjectsRequest::new().set_combine(CombineResultsOptions::default()/* use setters */);
    /// ```
    pub fn set_combine<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<
                crate::model::batch_search_data_objects_request::CombineResultsOptions,
            >,
    {
        self.combine = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [combine][crate::model::BatchSearchDataObjectsRequest::combine].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::BatchSearchDataObjectsRequest;
    /// use google_cloud_vectorsearch_v1::model::batch_search_data_objects_request::CombineResultsOptions;
    /// let x = BatchSearchDataObjectsRequest::new().set_or_clear_combine(Some(CombineResultsOptions::default()/* use setters */));
    /// let x = BatchSearchDataObjectsRequest::new().set_or_clear_combine(None::<CombineResultsOptions>);
    /// ```
    pub fn set_or_clear_combine<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<
                crate::model::batch_search_data_objects_request::CombineResultsOptions,
            >,
    {
        self.combine = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for BatchSearchDataObjectsRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.BatchSearchDataObjectsRequest"
    }
}

/// Defines additional types related to [BatchSearchDataObjectsRequest].
pub mod batch_search_data_objects_request {
    #[allow(unused_imports)]
    use super::*;

    /// Options for combining the results of the batch search operations.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct CombineResultsOptions {
        /// Required. The ranker to use for combining the results.
        pub ranker: std::option::Option<crate::model::Ranker>,

        /// Optional. Mask specifying which fields to return.
        pub output_fields: std::option::Option<crate::model::OutputFields>,

        /// Optional. The number of results to return. If not set, a default value
        /// will be used.
        pub top_k: i32,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl CombineResultsOptions {
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [ranker][crate::model::batch_search_data_objects_request::CombineResultsOptions::ranker].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_vectorsearch_v1::model::batch_search_data_objects_request::CombineResultsOptions;
        /// use google_cloud_vectorsearch_v1::model::Ranker;
        /// let x = CombineResultsOptions::new().set_ranker(Ranker::default()/* use setters */);
        /// ```
        pub fn set_ranker<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::model::Ranker>,
        {
            self.ranker = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [ranker][crate::model::batch_search_data_objects_request::CombineResultsOptions::ranker].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_vectorsearch_v1::model::batch_search_data_objects_request::CombineResultsOptions;
        /// use google_cloud_vectorsearch_v1::model::Ranker;
        /// let x = CombineResultsOptions::new().set_or_clear_ranker(Some(Ranker::default()/* use setters */));
        /// let x = CombineResultsOptions::new().set_or_clear_ranker(None::<Ranker>);
        /// ```
        pub fn set_or_clear_ranker<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<crate::model::Ranker>,
        {
            self.ranker = v.map(|x| x.into());
            self
        }

        /// Sets the value of [output_fields][crate::model::batch_search_data_objects_request::CombineResultsOptions::output_fields].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_vectorsearch_v1::model::batch_search_data_objects_request::CombineResultsOptions;
        /// use google_cloud_vectorsearch_v1::model::OutputFields;
        /// let x = CombineResultsOptions::new().set_output_fields(OutputFields::default()/* use setters */);
        /// ```
        pub fn set_output_fields<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::model::OutputFields>,
        {
            self.output_fields = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [output_fields][crate::model::batch_search_data_objects_request::CombineResultsOptions::output_fields].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_vectorsearch_v1::model::batch_search_data_objects_request::CombineResultsOptions;
        /// use google_cloud_vectorsearch_v1::model::OutputFields;
        /// let x = CombineResultsOptions::new().set_or_clear_output_fields(Some(OutputFields::default()/* use setters */));
        /// let x = CombineResultsOptions::new().set_or_clear_output_fields(None::<OutputFields>);
        /// ```
        pub fn set_or_clear_output_fields<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<crate::model::OutputFields>,
        {
            self.output_fields = v.map(|x| x.into());
            self
        }

        /// Sets the value of [top_k][crate::model::batch_search_data_objects_request::CombineResultsOptions::top_k].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_vectorsearch_v1::model::batch_search_data_objects_request::CombineResultsOptions;
        /// let x = CombineResultsOptions::new().set_top_k(42);
        /// ```
        pub fn set_top_k<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
            self.top_k = v.into();
            self
        }
    }

    impl wkt::message::Message for CombineResultsOptions {
        fn typename() -> &'static str {
            "type.googleapis.com/google.cloud.vectorsearch.v1.BatchSearchDataObjectsRequest.CombineResultsOptions"
        }
    }
}

/// Defines a ranker to combine results from multiple searches.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Ranker {
    /// The ranking method to use.
    pub ranker: std::option::Option<crate::model::ranker::Ranker>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl Ranker {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [ranker][crate::model::Ranker::ranker].
    ///
    /// Note that all the setters affecting `ranker` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::Ranker;
    /// use google_cloud_vectorsearch_v1::model::ReciprocalRankFusion;
    /// let x = Ranker::new().set_ranker(Some(
    ///     google_cloud_vectorsearch_v1::model::ranker::Ranker::Rrf(ReciprocalRankFusion::default().into())));
    /// ```
    pub fn set_ranker<T: std::convert::Into<std::option::Option<crate::model::ranker::Ranker>>>(
        mut self,
        v: T,
    ) -> Self {
        self.ranker = v.into();
        self
    }

    /// The value of [ranker][crate::model::Ranker::ranker]
    /// if it holds a `Rrf`, `None` if the field is not set or
    /// holds a different branch.
    pub fn rrf(&self) -> std::option::Option<&std::boxed::Box<crate::model::ReciprocalRankFusion>> {
        #[allow(unreachable_patterns)]
        self.ranker.as_ref().and_then(|v| match v {
            crate::model::ranker::Ranker::Rrf(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [ranker][crate::model::Ranker::ranker]
    /// to hold a `Rrf`.
    ///
    /// Note that all the setters affecting `ranker` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::Ranker;
    /// use google_cloud_vectorsearch_v1::model::ReciprocalRankFusion;
    /// let x = Ranker::new().set_rrf(ReciprocalRankFusion::default()/* use setters */);
    /// assert!(x.rrf().is_some());
    /// ```
    pub fn set_rrf<T: std::convert::Into<std::boxed::Box<crate::model::ReciprocalRankFusion>>>(
        mut self,
        v: T,
    ) -> Self {
        self.ranker = std::option::Option::Some(crate::model::ranker::Ranker::Rrf(v.into()));
        self
    }
}

impl wkt::message::Message for Ranker {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.Ranker"
    }
}

/// Defines additional types related to [Ranker].
pub mod ranker {
    #[allow(unused_imports)]
    use super::*;

    /// The ranking method to use.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Ranker {
        /// Reciprocal Rank Fusion ranking.
        Rrf(std::boxed::Box<crate::model::ReciprocalRankFusion>),
    }
}

/// Defines the Reciprocal Rank Fusion (RRF) algorithm for result ranking.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ReciprocalRankFusion {
    /// Required. The weights to apply to each search result set during fusion.
    pub weights: std::vec::Vec<f64>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ReciprocalRankFusion {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [weights][crate::model::ReciprocalRankFusion::weights].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::ReciprocalRankFusion;
    /// let x = ReciprocalRankFusion::new().set_weights([1.0, 2.0, 3.0]);
    /// ```
    pub fn set_weights<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<f64>,
    {
        use std::iter::Iterator;
        self.weights = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for ReciprocalRankFusion {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.ReciprocalRankFusion"
    }
}

/// A response from a batch search operation.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct BatchSearchDataObjectsResponse {
    /// Output only. A list of search responses, one for each request in the batch.
    /// If a ranker is used, a single ranked list of results is returned.
    pub results: std::vec::Vec<crate::model::SearchDataObjectsResponse>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl BatchSearchDataObjectsResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [results][crate::model::BatchSearchDataObjectsResponse::results].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::BatchSearchDataObjectsResponse;
    /// use google_cloud_vectorsearch_v1::model::SearchDataObjectsResponse;
    /// let x = BatchSearchDataObjectsResponse::new()
    ///     .set_results([
    ///         SearchDataObjectsResponse::default()/* use setters */,
    ///         SearchDataObjectsResponse::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_results<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::SearchDataObjectsResponse>,
    {
        use std::iter::Iterator;
        self.results = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for BatchSearchDataObjectsResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.BatchSearchDataObjectsResponse"
    }
}

/// Request message for
/// [DataObjectService.CreateDataObject][google.cloud.vectorsearch.v1.DataObjectService.CreateDataObject].
///
/// [google.cloud.vectorsearch.v1.DataObjectService.CreateDataObject]: crate::client::DataObjectService::create_data_object
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CreateDataObjectRequest {
    /// Required. The resource name of the Collection to create the DataObject in.
    /// Format: `projects/{project}/locations/{location}/collections/{collection}`
    pub parent: std::string::String,

    /// Required. The id of the dataObject to create.
    /// The id must be 1-63 characters long, and comply with
    /// [RFC1035](https://www.ietf.org/rfc/rfc1035.txt).
    /// Specifically, it must be 1-63 characters long and match the regular
    /// expression `[a-z](?:[-a-z0-9]{0,61}[a-z0-9])?`.
    pub data_object_id: std::string::String,

    /// Required. The DataObject to create.
    pub data_object: std::option::Option<crate::model::DataObject>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl CreateDataObjectRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::CreateDataObjectRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::CreateDataObjectRequest;
    /// let x = CreateDataObjectRequest::new().set_parent("example");
    /// ```
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [data_object_id][crate::model::CreateDataObjectRequest::data_object_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::CreateDataObjectRequest;
    /// let x = CreateDataObjectRequest::new().set_data_object_id("example");
    /// ```
    pub fn set_data_object_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.data_object_id = v.into();
        self
    }

    /// Sets the value of [data_object][crate::model::CreateDataObjectRequest::data_object].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::CreateDataObjectRequest;
    /// use google_cloud_vectorsearch_v1::model::DataObject;
    /// let x = CreateDataObjectRequest::new().set_data_object(DataObject::default()/* use setters */);
    /// ```
    pub fn set_data_object<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::DataObject>,
    {
        self.data_object = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [data_object][crate::model::CreateDataObjectRequest::data_object].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::CreateDataObjectRequest;
    /// use google_cloud_vectorsearch_v1::model::DataObject;
    /// let x = CreateDataObjectRequest::new().set_or_clear_data_object(Some(DataObject::default()/* use setters */));
    /// let x = CreateDataObjectRequest::new().set_or_clear_data_object(None::<DataObject>);
    /// ```
    pub fn set_or_clear_data_object<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::DataObject>,
    {
        self.data_object = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for CreateDataObjectRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.CreateDataObjectRequest"
    }
}

/// Request message for
/// [DataObjectService.BatchCreateDataObjects][google.cloud.vectorsearch.v1.DataObjectService.BatchCreateDataObjects].
///
/// [google.cloud.vectorsearch.v1.DataObjectService.BatchCreateDataObjects]: crate::client::DataObjectService::batch_create_data_objects
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct BatchCreateDataObjectsRequest {
    /// Required. The resource name of the Collection to create the DataObjects in.
    /// Format: `projects/{project}/locations/{location}/collections/{collection}`.
    /// The parent field in the CreateDataObjectRequest messages must match this
    /// field.
    pub parent: std::string::String,

    /// Required. The request message specifying the resources to create.
    /// A maximum of 1000 DataObjects can be created in a batch.
    pub requests: std::vec::Vec<crate::model::CreateDataObjectRequest>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl BatchCreateDataObjectsRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::BatchCreateDataObjectsRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::BatchCreateDataObjectsRequest;
    /// let x = BatchCreateDataObjectsRequest::new().set_parent("example");
    /// ```
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [requests][crate::model::BatchCreateDataObjectsRequest::requests].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::BatchCreateDataObjectsRequest;
    /// use google_cloud_vectorsearch_v1::model::CreateDataObjectRequest;
    /// let x = BatchCreateDataObjectsRequest::new()
    ///     .set_requests([
    ///         CreateDataObjectRequest::default()/* use setters */,
    ///         CreateDataObjectRequest::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_requests<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::CreateDataObjectRequest>,
    {
        use std::iter::Iterator;
        self.requests = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for BatchCreateDataObjectsRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.BatchCreateDataObjectsRequest"
    }
}

/// Response message for
/// [DataObjectService.BatchCreateDataObjects][google.cloud.vectorsearch.v1.DataObjectService.BatchCreateDataObjects].
///
/// [google.cloud.vectorsearch.v1.DataObjectService.BatchCreateDataObjects]: crate::client::DataObjectService::batch_create_data_objects
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct BatchCreateDataObjectsResponse {
    /// Output only. DataObjects created.
    pub data_objects: std::vec::Vec<crate::model::DataObject>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl BatchCreateDataObjectsResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [data_objects][crate::model::BatchCreateDataObjectsResponse::data_objects].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::BatchCreateDataObjectsResponse;
    /// use google_cloud_vectorsearch_v1::model::DataObject;
    /// let x = BatchCreateDataObjectsResponse::new()
    ///     .set_data_objects([
    ///         DataObject::default()/* use setters */,
    ///         DataObject::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_data_objects<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::DataObject>,
    {
        use std::iter::Iterator;
        self.data_objects = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for BatchCreateDataObjectsResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.BatchCreateDataObjectsResponse"
    }
}

/// Request message for
/// [DataObjectService.GetDataObject][google.cloud.vectorsearch.v1.DataObjectService.GetDataObject].
///
/// [google.cloud.vectorsearch.v1.DataObjectService.GetDataObject]: crate::client::DataObjectService::get_data_object
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GetDataObjectRequest {
    /// Required. The name of the DataObject resource.
    /// Format:
    /// `projects/{project}/locations/{location}/collections/{collection}/dataObjects/{dataObject}`
    pub name: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl GetDataObjectRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::GetDataObjectRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::GetDataObjectRequest;
    /// let x = GetDataObjectRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for GetDataObjectRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.GetDataObjectRequest"
    }
}

/// Request message for
/// [DataObjectService.UpdateDataObject][google.cloud.vectorsearch.v1.DataObjectService.UpdateDataObject].
///
/// [google.cloud.vectorsearch.v1.DataObjectService.UpdateDataObject]: crate::client::DataObjectService::update_data_object
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct UpdateDataObjectRequest {
    /// Required. The DataObject which replaces the resource on the server.
    pub data_object: std::option::Option<crate::model::DataObject>,

    /// Optional. The update mask applies to the resource. See
    /// [google.protobuf.FieldMask][google.protobuf.FieldMask].
    ///
    /// [google.protobuf.FieldMask]: wkt::FieldMask
    pub update_mask: std::option::Option<wkt::FieldMask>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl UpdateDataObjectRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [data_object][crate::model::UpdateDataObjectRequest::data_object].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::UpdateDataObjectRequest;
    /// use google_cloud_vectorsearch_v1::model::DataObject;
    /// let x = UpdateDataObjectRequest::new().set_data_object(DataObject::default()/* use setters */);
    /// ```
    pub fn set_data_object<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::DataObject>,
    {
        self.data_object = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [data_object][crate::model::UpdateDataObjectRequest::data_object].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::UpdateDataObjectRequest;
    /// use google_cloud_vectorsearch_v1::model::DataObject;
    /// let x = UpdateDataObjectRequest::new().set_or_clear_data_object(Some(DataObject::default()/* use setters */));
    /// let x = UpdateDataObjectRequest::new().set_or_clear_data_object(None::<DataObject>);
    /// ```
    pub fn set_or_clear_data_object<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::DataObject>,
    {
        self.data_object = v.map(|x| x.into());
        self
    }

    /// Sets the value of [update_mask][crate::model::UpdateDataObjectRequest::update_mask].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::UpdateDataObjectRequest;
    /// use wkt::FieldMask;
    /// let x = UpdateDataObjectRequest::new().set_update_mask(FieldMask::default()/* use setters */);
    /// ```
    pub fn set_update_mask<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::FieldMask>,
    {
        self.update_mask = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [update_mask][crate::model::UpdateDataObjectRequest::update_mask].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::UpdateDataObjectRequest;
    /// use wkt::FieldMask;
    /// let x = UpdateDataObjectRequest::new().set_or_clear_update_mask(Some(FieldMask::default()/* use setters */));
    /// let x = UpdateDataObjectRequest::new().set_or_clear_update_mask(None::<FieldMask>);
    /// ```
    pub fn set_or_clear_update_mask<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::FieldMask>,
    {
        self.update_mask = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for UpdateDataObjectRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.UpdateDataObjectRequest"
    }
}

/// Request message for
/// [DataObjectService.BatchUpdateDataObjects][google.cloud.vectorsearch.v1.DataObjectService.BatchUpdateDataObjects].
///
/// [google.cloud.vectorsearch.v1.DataObjectService.BatchUpdateDataObjects]: crate::client::DataObjectService::batch_update_data_objects
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct BatchUpdateDataObjectsRequest {
    /// Required. The resource name of the Collection to update the DataObjects in.
    /// Format: `projects/{project}/locations/{location}/collections/{collection}`.
    /// The parent field in the UpdateDataObjectRequest messages must match this
    /// field.
    pub parent: std::string::String,

    /// Required. The request message specifying the resources to update.
    /// A maximum of 1000 DataObjects can be updated in a batch.
    pub requests: std::vec::Vec<crate::model::UpdateDataObjectRequest>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl BatchUpdateDataObjectsRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::BatchUpdateDataObjectsRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::BatchUpdateDataObjectsRequest;
    /// let x = BatchUpdateDataObjectsRequest::new().set_parent("example");
    /// ```
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [requests][crate::model::BatchUpdateDataObjectsRequest::requests].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::BatchUpdateDataObjectsRequest;
    /// use google_cloud_vectorsearch_v1::model::UpdateDataObjectRequest;
    /// let x = BatchUpdateDataObjectsRequest::new()
    ///     .set_requests([
    ///         UpdateDataObjectRequest::default()/* use setters */,
    ///         UpdateDataObjectRequest::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_requests<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::UpdateDataObjectRequest>,
    {
        use std::iter::Iterator;
        self.requests = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for BatchUpdateDataObjectsRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.BatchUpdateDataObjectsRequest"
    }
}

/// Response message for
/// [DataObjectService.BatchUpdateDataObjects][google.cloud.vectorsearch.v1.DataObjectService.BatchUpdateDataObjects].
///
/// [google.cloud.vectorsearch.v1.DataObjectService.BatchUpdateDataObjects]: crate::client::DataObjectService::batch_update_data_objects
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct BatchUpdateDataObjectsResponse {
    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl BatchUpdateDataObjectsResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }
}

impl wkt::message::Message for BatchUpdateDataObjectsResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.BatchUpdateDataObjectsResponse"
    }
}

/// Request message for
/// [DataObjectService.DeleteDataObject][google.cloud.vectorsearch.v1.DataObjectService.DeleteDataObject].
///
/// [google.cloud.vectorsearch.v1.DataObjectService.DeleteDataObject]: crate::client::DataObjectService::delete_data_object
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DeleteDataObjectRequest {
    /// Required. The name of the DataObject resource to be deleted.
    /// Format:
    /// `projects/{project}/locations/{location}/collections/{collection}/dataObjects/{dataObject}`
    pub name: std::string::String,

    /// Optional. The current etag of the DataObject.
    /// If an etag is provided and does not match the current etag of the
    /// DataObject, deletion will be blocked and an ABORTED error will be returned.
    pub etag: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl DeleteDataObjectRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::DeleteDataObjectRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::DeleteDataObjectRequest;
    /// let x = DeleteDataObjectRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [etag][crate::model::DeleteDataObjectRequest::etag].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::DeleteDataObjectRequest;
    /// let x = DeleteDataObjectRequest::new().set_etag("example");
    /// ```
    pub fn set_etag<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.etag = v.into();
        self
    }
}

impl wkt::message::Message for DeleteDataObjectRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.DeleteDataObjectRequest"
    }
}

/// Request message for
/// [DataObjectService.BatchDeleteDataObjects][google.cloud.vectorsearch.v1.DataObjectService.BatchDeleteDataObjects].
///
/// [google.cloud.vectorsearch.v1.DataObjectService.BatchDeleteDataObjects]: crate::client::DataObjectService::batch_delete_data_objects
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct BatchDeleteDataObjectsRequest {
    /// Required. The resource name of the Collection to delete the DataObjects in.
    /// Format: `projects/{project}/locations/{location}/collections/{collection}`.
    pub parent: std::string::String,

    /// Required. The request message specifying the resources to delete.
    /// A maximum of 1000 DataObjects can be deleted in a batch.
    pub requests: std::vec::Vec<crate::model::DeleteDataObjectRequest>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl BatchDeleteDataObjectsRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::BatchDeleteDataObjectsRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::BatchDeleteDataObjectsRequest;
    /// let x = BatchDeleteDataObjectsRequest::new().set_parent("example");
    /// ```
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [requests][crate::model::BatchDeleteDataObjectsRequest::requests].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::BatchDeleteDataObjectsRequest;
    /// use google_cloud_vectorsearch_v1::model::DeleteDataObjectRequest;
    /// let x = BatchDeleteDataObjectsRequest::new()
    ///     .set_requests([
    ///         DeleteDataObjectRequest::default()/* use setters */,
    ///         DeleteDataObjectRequest::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_requests<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::DeleteDataObjectRequest>,
    {
        use std::iter::Iterator;
        self.requests = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for BatchDeleteDataObjectsRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.BatchDeleteDataObjectsRequest"
    }
}

/// Message describing the configuration for generating embeddings for a vector
/// field using Vertex AI embeddings API.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct VertexEmbeddingConfig {
    /// Required. Required: ID of the embedding model to use. See
    /// <https://cloud.google.com/vertex-ai/generative-ai/docs/learn/models#embeddings-models>
    /// for the list of supported models.
    pub model_id: std::string::String,

    /// Required. Required: Text template for the input to the model. The template
    /// must contain one or more references to fields in the DataObject, e.g.:
    /// "Movie Title: {title} ---- Movie Plot: {plot}".
    pub text_template: std::string::String,

    /// Required. Required: Task type for the embeddings.
    pub task_type: crate::model::EmbeddingTaskType,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl VertexEmbeddingConfig {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [model_id][crate::model::VertexEmbeddingConfig::model_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::VertexEmbeddingConfig;
    /// let x = VertexEmbeddingConfig::new().set_model_id("example");
    /// ```
    pub fn set_model_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.model_id = v.into();
        self
    }

    /// Sets the value of [text_template][crate::model::VertexEmbeddingConfig::text_template].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::VertexEmbeddingConfig;
    /// let x = VertexEmbeddingConfig::new().set_text_template("example");
    /// ```
    pub fn set_text_template<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.text_template = v.into();
        self
    }

    /// Sets the value of [task_type][crate::model::VertexEmbeddingConfig::task_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::VertexEmbeddingConfig;
    /// use google_cloud_vectorsearch_v1::model::EmbeddingTaskType;
    /// let x0 = VertexEmbeddingConfig::new().set_task_type(EmbeddingTaskType::RetrievalQuery);
    /// let x1 = VertexEmbeddingConfig::new().set_task_type(EmbeddingTaskType::RetrievalDocument);
    /// let x2 = VertexEmbeddingConfig::new().set_task_type(EmbeddingTaskType::SemanticSimilarity);
    /// ```
    pub fn set_task_type<T: std::convert::Into<crate::model::EmbeddingTaskType>>(
        mut self,
        v: T,
    ) -> Self {
        self.task_type = v.into();
        self
    }
}

impl wkt::message::Message for VertexEmbeddingConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.VertexEmbeddingConfig"
    }
}

/// Message describing Collection object
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Collection {
    /// Identifier. name of resource
    pub name: std::string::String,

    /// Optional. User-specified display name of the collection
    pub display_name: std::string::String,

    /// Optional. User-specified description of the collection
    pub description: std::string::String,

    /// Output only. [Output only] Create time stamp
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. [Output only] Update time stamp
    pub update_time: std::option::Option<wkt::Timestamp>,

    /// Optional. Labels as key value pairs.
    pub labels: std::collections::HashMap<std::string::String, std::string::String>,

    /// Optional. Schema for vector fields. Only vector fields in this schema will
    /// be searchable. Field names must contain only alphanumeric characters,
    /// underscores, and hyphens.
    pub vector_schema: std::collections::HashMap<std::string::String, crate::model::VectorField>,

    /// Optional. JSON Schema for data.
    /// Field names must contain only alphanumeric characters,
    /// underscores, and hyphens.
    pub data_schema: std::option::Option<wkt::Struct>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl Collection {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::Collection::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::Collection;
    /// let x = Collection::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [display_name][crate::model::Collection::display_name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::Collection;
    /// let x = Collection::new().set_display_name("example");
    /// ```
    pub fn set_display_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.display_name = v.into();
        self
    }

    /// Sets the value of [description][crate::model::Collection::description].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::Collection;
    /// let x = Collection::new().set_description("example");
    /// ```
    pub fn set_description<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.description = v.into();
        self
    }

    /// Sets the value of [create_time][crate::model::Collection::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::Collection;
    /// use wkt::Timestamp;
    /// let x = Collection::new().set_create_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_create_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.create_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [create_time][crate::model::Collection::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::Collection;
    /// use wkt::Timestamp;
    /// let x = Collection::new().set_or_clear_create_time(Some(Timestamp::default()/* use setters */));
    /// let x = Collection::new().set_or_clear_create_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_create_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.create_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [update_time][crate::model::Collection::update_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::Collection;
    /// use wkt::Timestamp;
    /// let x = Collection::new().set_update_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_update_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.update_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [update_time][crate::model::Collection::update_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::Collection;
    /// use wkt::Timestamp;
    /// let x = Collection::new().set_or_clear_update_time(Some(Timestamp::default()/* use setters */));
    /// let x = Collection::new().set_or_clear_update_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_update_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.update_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [labels][crate::model::Collection::labels].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::Collection;
    /// let x = Collection::new().set_labels([
    ///     ("key0", "abc"),
    ///     ("key1", "xyz"),
    /// ]);
    /// ```
    pub fn set_labels<T, K, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = (K, V)>,
        K: std::convert::Into<std::string::String>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.labels = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }

    /// Sets the value of [vector_schema][crate::model::Collection::vector_schema].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::Collection;
    /// use google_cloud_vectorsearch_v1::model::VectorField;
    /// let x = Collection::new().set_vector_schema([
    ///     ("key0", VectorField::default()/* use setters */),
    ///     ("key1", VectorField::default()/* use (different) setters */),
    /// ]);
    /// ```
    pub fn set_vector_schema<T, K, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = (K, V)>,
        K: std::convert::Into<std::string::String>,
        V: std::convert::Into<crate::model::VectorField>,
    {
        use std::iter::Iterator;
        self.vector_schema = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }

    /// Sets the value of [data_schema][crate::model::Collection::data_schema].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::Collection;
    /// use wkt::Struct;
    /// let x = Collection::new().set_data_schema(Struct::default()/* use setters */);
    /// ```
    pub fn set_data_schema<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Struct>,
    {
        self.data_schema = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [data_schema][crate::model::Collection::data_schema].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::Collection;
    /// use wkt::Struct;
    /// let x = Collection::new().set_or_clear_data_schema(Some(Struct::default()/* use setters */));
    /// let x = Collection::new().set_or_clear_data_schema(None::<Struct>);
    /// ```
    pub fn set_or_clear_data_schema<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Struct>,
    {
        self.data_schema = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for Collection {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.Collection"
    }
}

/// Message describing a vector field.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct VectorField {
    /// Vector type configuration.
    pub vector_type_config: std::option::Option<crate::model::vector_field::VectorTypeConfig>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl VectorField {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [vector_type_config][crate::model::VectorField::vector_type_config].
    ///
    /// Note that all the setters affecting `vector_type_config` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::VectorField;
    /// use google_cloud_vectorsearch_v1::model::DenseVectorField;
    /// let x = VectorField::new().set_vector_type_config(Some(
    ///     google_cloud_vectorsearch_v1::model::vector_field::VectorTypeConfig::DenseVector(DenseVectorField::default().into())));
    /// ```
    pub fn set_vector_type_config<
        T: std::convert::Into<std::option::Option<crate::model::vector_field::VectorTypeConfig>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.vector_type_config = v.into();
        self
    }

    /// The value of [vector_type_config][crate::model::VectorField::vector_type_config]
    /// if it holds a `DenseVector`, `None` if the field is not set or
    /// holds a different branch.
    pub fn dense_vector(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::DenseVectorField>> {
        #[allow(unreachable_patterns)]
        self.vector_type_config.as_ref().and_then(|v| match v {
            crate::model::vector_field::VectorTypeConfig::DenseVector(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [vector_type_config][crate::model::VectorField::vector_type_config]
    /// to hold a `DenseVector`.
    ///
    /// Note that all the setters affecting `vector_type_config` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::VectorField;
    /// use google_cloud_vectorsearch_v1::model::DenseVectorField;
    /// let x = VectorField::new().set_dense_vector(DenseVectorField::default()/* use setters */);
    /// assert!(x.dense_vector().is_some());
    /// assert!(x.sparse_vector().is_none());
    /// ```
    pub fn set_dense_vector<
        T: std::convert::Into<std::boxed::Box<crate::model::DenseVectorField>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.vector_type_config = std::option::Option::Some(
            crate::model::vector_field::VectorTypeConfig::DenseVector(v.into()),
        );
        self
    }

    /// The value of [vector_type_config][crate::model::VectorField::vector_type_config]
    /// if it holds a `SparseVector`, `None` if the field is not set or
    /// holds a different branch.
    pub fn sparse_vector(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::SparseVectorField>> {
        #[allow(unreachable_patterns)]
        self.vector_type_config.as_ref().and_then(|v| match v {
            crate::model::vector_field::VectorTypeConfig::SparseVector(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [vector_type_config][crate::model::VectorField::vector_type_config]
    /// to hold a `SparseVector`.
    ///
    /// Note that all the setters affecting `vector_type_config` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::VectorField;
    /// use google_cloud_vectorsearch_v1::model::SparseVectorField;
    /// let x = VectorField::new().set_sparse_vector(SparseVectorField::default()/* use setters */);
    /// assert!(x.sparse_vector().is_some());
    /// assert!(x.dense_vector().is_none());
    /// ```
    pub fn set_sparse_vector<
        T: std::convert::Into<std::boxed::Box<crate::model::SparseVectorField>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.vector_type_config = std::option::Option::Some(
            crate::model::vector_field::VectorTypeConfig::SparseVector(v.into()),
        );
        self
    }
}

impl wkt::message::Message for VectorField {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.VectorField"
    }
}

/// Defines additional types related to [VectorField].
pub mod vector_field {
    #[allow(unused_imports)]
    use super::*;

    /// Vector type configuration.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum VectorTypeConfig {
        /// Dense vector field.
        DenseVector(std::boxed::Box<crate::model::DenseVectorField>),
        /// Sparse vector field.
        SparseVector(std::boxed::Box<crate::model::SparseVectorField>),
    }
}

/// Message describing a dense vector field.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DenseVectorField {
    /// Dimensionality of the vector field.
    pub dimensions: i32,

    /// Optional. Configuration for generating embeddings for the vector field. If
    /// not specified, the embedding field must be populated in the DataObject.
    pub vertex_embedding_config: std::option::Option<crate::model::VertexEmbeddingConfig>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl DenseVectorField {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [dimensions][crate::model::DenseVectorField::dimensions].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::DenseVectorField;
    /// let x = DenseVectorField::new().set_dimensions(42);
    /// ```
    pub fn set_dimensions<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.dimensions = v.into();
        self
    }

    /// Sets the value of [vertex_embedding_config][crate::model::DenseVectorField::vertex_embedding_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::DenseVectorField;
    /// use google_cloud_vectorsearch_v1::model::VertexEmbeddingConfig;
    /// let x = DenseVectorField::new().set_vertex_embedding_config(VertexEmbeddingConfig::default()/* use setters */);
    /// ```
    pub fn set_vertex_embedding_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::VertexEmbeddingConfig>,
    {
        self.vertex_embedding_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [vertex_embedding_config][crate::model::DenseVectorField::vertex_embedding_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::DenseVectorField;
    /// use google_cloud_vectorsearch_v1::model::VertexEmbeddingConfig;
    /// let x = DenseVectorField::new().set_or_clear_vertex_embedding_config(Some(VertexEmbeddingConfig::default()/* use setters */));
    /// let x = DenseVectorField::new().set_or_clear_vertex_embedding_config(None::<VertexEmbeddingConfig>);
    /// ```
    pub fn set_or_clear_vertex_embedding_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::VertexEmbeddingConfig>,
    {
        self.vertex_embedding_config = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for DenseVectorField {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.DenseVectorField"
    }
}

/// Message describing a sparse vector field.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SparseVectorField {
    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SparseVectorField {
    pub fn new() -> Self {
        std::default::Default::default()
    }
}

impl wkt::message::Message for SparseVectorField {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.SparseVectorField"
    }
}

/// Message for requesting list of Collections
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListCollectionsRequest {
    /// Required. Parent value for ListCollectionsRequest
    pub parent: std::string::String,

    /// Optional. Requested page size. Server may return fewer items than
    /// requested. If unspecified, server will pick an appropriate default.
    pub page_size: i32,

    /// Optional. A token identifying a page of results the server should return.
    pub page_token: std::string::String,

    /// Optional. Filtering results
    pub filter: std::string::String,

    /// Optional. Hint for how to order the results
    pub order_by: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ListCollectionsRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::ListCollectionsRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::ListCollectionsRequest;
    /// let x = ListCollectionsRequest::new().set_parent("example");
    /// ```
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [page_size][crate::model::ListCollectionsRequest::page_size].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::ListCollectionsRequest;
    /// let x = ListCollectionsRequest::new().set_page_size(42);
    /// ```
    pub fn set_page_size<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.page_size = v.into();
        self
    }

    /// Sets the value of [page_token][crate::model::ListCollectionsRequest::page_token].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::ListCollectionsRequest;
    /// let x = ListCollectionsRequest::new().set_page_token("example");
    /// ```
    pub fn set_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.page_token = v.into();
        self
    }

    /// Sets the value of [filter][crate::model::ListCollectionsRequest::filter].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::ListCollectionsRequest;
    /// let x = ListCollectionsRequest::new().set_filter("example");
    /// ```
    pub fn set_filter<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.filter = v.into();
        self
    }

    /// Sets the value of [order_by][crate::model::ListCollectionsRequest::order_by].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::ListCollectionsRequest;
    /// let x = ListCollectionsRequest::new().set_order_by("example");
    /// ```
    pub fn set_order_by<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.order_by = v.into();
        self
    }
}

impl wkt::message::Message for ListCollectionsRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.ListCollectionsRequest"
    }
}

/// Message for response to listing Collections
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListCollectionsResponse {
    /// The list of Collection
    pub collections: std::vec::Vec<crate::model::Collection>,

    /// A token identifying a page of results the server should return.
    pub next_page_token: std::string::String,

    /// Unordered list. Locations that could not be reached.
    pub unreachable: std::vec::Vec<std::string::String>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ListCollectionsResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [collections][crate::model::ListCollectionsResponse::collections].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::ListCollectionsResponse;
    /// use google_cloud_vectorsearch_v1::model::Collection;
    /// let x = ListCollectionsResponse::new()
    ///     .set_collections([
    ///         Collection::default()/* use setters */,
    ///         Collection::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_collections<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::Collection>,
    {
        use std::iter::Iterator;
        self.collections = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [next_page_token][crate::model::ListCollectionsResponse::next_page_token].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::ListCollectionsResponse;
    /// let x = ListCollectionsResponse::new().set_next_page_token("example");
    /// ```
    pub fn set_next_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.next_page_token = v.into();
        self
    }

    /// Sets the value of [unreachable][crate::model::ListCollectionsResponse::unreachable].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::ListCollectionsResponse;
    /// let x = ListCollectionsResponse::new().set_unreachable(["a", "b", "c"]);
    /// ```
    pub fn set_unreachable<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.unreachable = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for ListCollectionsResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.ListCollectionsResponse"
    }
}

#[doc(hidden)]
impl google_cloud_gax::paginator::internal::PageableResponse for ListCollectionsResponse {
    type PageItem = crate::model::Collection;

    fn items(self) -> std::vec::Vec<Self::PageItem> {
        self.collections
    }

    fn next_page_token(&self) -> std::string::String {
        use std::clone::Clone;
        self.next_page_token.clone()
    }
}

/// Message for getting a Collection
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GetCollectionRequest {
    /// Required. Name of the resource
    pub name: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl GetCollectionRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::GetCollectionRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::GetCollectionRequest;
    /// let x = GetCollectionRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for GetCollectionRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.GetCollectionRequest"
    }
}

/// Message for creating a Collection
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CreateCollectionRequest {
    /// Required. Value for parent.
    pub parent: std::string::String,

    /// Required. ID of the Collection to create.
    /// The id must be 1-63 characters long, and comply with
    /// [RFC1035](https://www.ietf.org/rfc/rfc1035.txt).
    /// Specifically, it must be 1-63 characters long and match the regular
    /// expression `[a-z](?:[-a-z0-9]{0,61}[a-z0-9])?`.
    pub collection_id: std::string::String,

    /// Required. The resource being created
    pub collection: std::option::Option<crate::model::Collection>,

    /// Optional. An optional request ID to identify requests. Specify a unique
    /// request ID so that if you must retry your request, the server will know to
    /// ignore the request if it has already been completed. The server will
    /// guarantee that for at least 60 minutes since the first request.
    ///
    /// For example, consider a situation where you make an initial request and the
    /// request times out. If you make the request again with the same request
    /// ID, the server can check if original operation with the same request ID
    /// was received, and if so, will ignore the second request. This prevents
    /// clients from accidentally creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID with the exception that zero UUID is
    /// not supported (00000000-0000-0000-0000-000000000000).
    pub request_id: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl CreateCollectionRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::CreateCollectionRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::CreateCollectionRequest;
    /// let x = CreateCollectionRequest::new().set_parent("example");
    /// ```
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [collection_id][crate::model::CreateCollectionRequest::collection_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::CreateCollectionRequest;
    /// let x = CreateCollectionRequest::new().set_collection_id("example");
    /// ```
    pub fn set_collection_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.collection_id = v.into();
        self
    }

    /// Sets the value of [collection][crate::model::CreateCollectionRequest::collection].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::CreateCollectionRequest;
    /// use google_cloud_vectorsearch_v1::model::Collection;
    /// let x = CreateCollectionRequest::new().set_collection(Collection::default()/* use setters */);
    /// ```
    pub fn set_collection<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::Collection>,
    {
        self.collection = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [collection][crate::model::CreateCollectionRequest::collection].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::CreateCollectionRequest;
    /// use google_cloud_vectorsearch_v1::model::Collection;
    /// let x = CreateCollectionRequest::new().set_or_clear_collection(Some(Collection::default()/* use setters */));
    /// let x = CreateCollectionRequest::new().set_or_clear_collection(None::<Collection>);
    /// ```
    pub fn set_or_clear_collection<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::Collection>,
    {
        self.collection = v.map(|x| x.into());
        self
    }

    /// Sets the value of [request_id][crate::model::CreateCollectionRequest::request_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::CreateCollectionRequest;
    /// let x = CreateCollectionRequest::new().set_request_id("example");
    /// ```
    pub fn set_request_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.request_id = v.into();
        self
    }
}

impl wkt::message::Message for CreateCollectionRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.CreateCollectionRequest"
    }
}

/// Message for updating a Collection
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct UpdateCollectionRequest {
    /// Optional. Field mask is used to specify the fields to be overwritten in the
    /// Collection resource by the update.
    /// The fields specified in the update_mask are relative to the resource, not
    /// the full request. A field will be overwritten if it is in the mask. If the
    /// user does not provide a mask then all fields present in the request will be
    /// overwritten.
    ///
    /// The following fields support update: `display_name`, `description`,
    /// `labels`, `data_schema`, `vector_schema`.
    /// For `data_schema` and `vector_schema`, fields can only be added, not
    /// deleted, but `vertex_embedding_config` in `vector_schema` can be added or
    /// removed.
    /// Partial updates for `data_schema` and `vector_schema` are also supported
    /// by using sub-field paths in `update_mask`, e.g.
    /// `data_schema.properties.foo` or `vector_schema.my_vector_field`.
    ///
    /// If `*` is provided in the update_mask, full replacement will be performed.
    pub update_mask: std::option::Option<wkt::FieldMask>,

    /// Required. The resource being updated
    pub collection: std::option::Option<crate::model::Collection>,

    /// Optional. An optional request ID to identify requests. Specify a unique
    /// request ID so that if you must retry your request, the server will know to
    /// ignore the request if it has already been completed. The server will
    /// guarantee that for at least 60 minutes since the first request.
    ///
    /// For example, consider a situation where you make an initial request and the
    /// request times out. If you make the request again with the same request
    /// ID, the server can check if original operation with the same request ID
    /// was received, and if so, will ignore the second request. This prevents
    /// clients from accidentally creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID with the exception that zero UUID is
    /// not supported (00000000-0000-0000-0000-000000000000).
    pub request_id: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl UpdateCollectionRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [update_mask][crate::model::UpdateCollectionRequest::update_mask].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::UpdateCollectionRequest;
    /// use wkt::FieldMask;
    /// let x = UpdateCollectionRequest::new().set_update_mask(FieldMask::default()/* use setters */);
    /// ```
    pub fn set_update_mask<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::FieldMask>,
    {
        self.update_mask = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [update_mask][crate::model::UpdateCollectionRequest::update_mask].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::UpdateCollectionRequest;
    /// use wkt::FieldMask;
    /// let x = UpdateCollectionRequest::new().set_or_clear_update_mask(Some(FieldMask::default()/* use setters */));
    /// let x = UpdateCollectionRequest::new().set_or_clear_update_mask(None::<FieldMask>);
    /// ```
    pub fn set_or_clear_update_mask<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::FieldMask>,
    {
        self.update_mask = v.map(|x| x.into());
        self
    }

    /// Sets the value of [collection][crate::model::UpdateCollectionRequest::collection].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::UpdateCollectionRequest;
    /// use google_cloud_vectorsearch_v1::model::Collection;
    /// let x = UpdateCollectionRequest::new().set_collection(Collection::default()/* use setters */);
    /// ```
    pub fn set_collection<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::Collection>,
    {
        self.collection = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [collection][crate::model::UpdateCollectionRequest::collection].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::UpdateCollectionRequest;
    /// use google_cloud_vectorsearch_v1::model::Collection;
    /// let x = UpdateCollectionRequest::new().set_or_clear_collection(Some(Collection::default()/* use setters */));
    /// let x = UpdateCollectionRequest::new().set_or_clear_collection(None::<Collection>);
    /// ```
    pub fn set_or_clear_collection<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::Collection>,
    {
        self.collection = v.map(|x| x.into());
        self
    }

    /// Sets the value of [request_id][crate::model::UpdateCollectionRequest::request_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::UpdateCollectionRequest;
    /// let x = UpdateCollectionRequest::new().set_request_id("example");
    /// ```
    pub fn set_request_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.request_id = v.into();
        self
    }
}

impl wkt::message::Message for UpdateCollectionRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.UpdateCollectionRequest"
    }
}

/// Message for deleting a Collection
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DeleteCollectionRequest {
    /// Required. Name of the resource
    pub name: std::string::String,

    /// Optional. An optional request ID to identify requests. Specify a unique
    /// request ID so that if you must retry your request, the server will know to
    /// ignore the request if it has already been completed. The server will
    /// guarantee that for at least 60 minutes after the first request.
    ///
    /// For example, consider a situation where you make an initial request and the
    /// request times out. If you make the request again with the same request
    /// ID, the server can check if original operation with the same request ID
    /// was received, and if so, will ignore the second request. This prevents
    /// clients from accidentally creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID with the exception that zero UUID is
    /// not supported (00000000-0000-0000-0000-000000000000).
    pub request_id: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl DeleteCollectionRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::DeleteCollectionRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::DeleteCollectionRequest;
    /// let x = DeleteCollectionRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [request_id][crate::model::DeleteCollectionRequest::request_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::DeleteCollectionRequest;
    /// let x = DeleteCollectionRequest::new().set_request_id("example");
    /// ```
    pub fn set_request_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.request_id = v.into();
        self
    }
}

impl wkt::message::Message for DeleteCollectionRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.DeleteCollectionRequest"
    }
}

/// Message describing Index object
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Index {
    /// Identifier. name of resource
    pub name: std::string::String,

    /// Optional. User-specified display name of the index
    pub display_name: std::string::String,

    /// Optional. User-specified description of the index
    pub description: std::string::String,

    /// Optional. Labels as key value pairs.
    pub labels: std::collections::HashMap<std::string::String, std::string::String>,

    /// Output only. [Output only] Create time stamp
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. [Output only] Update time stamp
    pub update_time: std::option::Option<wkt::Timestamp>,

    /// Optional. Distance metric used for indexing. If not specified, will default
    /// to DOT_PRODUCT.
    pub distance_metric: crate::model::DistanceMetric,

    /// Required. The collection schema field to index.
    pub index_field: std::string::String,

    /// Optional. The fields to push into the index to enable fast ANN inline
    /// filtering.
    pub filter_fields: std::vec::Vec<std::string::String>,

    /// Optional. The fields to push into the index to enable inline data
    /// retrieval.
    pub store_fields: std::vec::Vec<std::string::String>,

    /// The infrastructure type of the index.
    pub infra_type: std::option::Option<crate::model::index::InfraType>,

    /// The type of the index.
    pub index_type: std::option::Option<crate::model::index::IndexType>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl Index {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::Index::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::Index;
    /// let x = Index::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [display_name][crate::model::Index::display_name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::Index;
    /// let x = Index::new().set_display_name("example");
    /// ```
    pub fn set_display_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.display_name = v.into();
        self
    }

    /// Sets the value of [description][crate::model::Index::description].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::Index;
    /// let x = Index::new().set_description("example");
    /// ```
    pub fn set_description<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.description = v.into();
        self
    }

    /// Sets the value of [labels][crate::model::Index::labels].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::Index;
    /// let x = Index::new().set_labels([
    ///     ("key0", "abc"),
    ///     ("key1", "xyz"),
    /// ]);
    /// ```
    pub fn set_labels<T, K, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = (K, V)>,
        K: std::convert::Into<std::string::String>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.labels = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }

    /// Sets the value of [create_time][crate::model::Index::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::Index;
    /// use wkt::Timestamp;
    /// let x = Index::new().set_create_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_create_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.create_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [create_time][crate::model::Index::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::Index;
    /// use wkt::Timestamp;
    /// let x = Index::new().set_or_clear_create_time(Some(Timestamp::default()/* use setters */));
    /// let x = Index::new().set_or_clear_create_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_create_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.create_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [update_time][crate::model::Index::update_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::Index;
    /// use wkt::Timestamp;
    /// let x = Index::new().set_update_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_update_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.update_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [update_time][crate::model::Index::update_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::Index;
    /// use wkt::Timestamp;
    /// let x = Index::new().set_or_clear_update_time(Some(Timestamp::default()/* use setters */));
    /// let x = Index::new().set_or_clear_update_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_update_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.update_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [distance_metric][crate::model::Index::distance_metric].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::Index;
    /// use google_cloud_vectorsearch_v1::model::DistanceMetric;
    /// let x0 = Index::new().set_distance_metric(DistanceMetric::DotProduct);
    /// let x1 = Index::new().set_distance_metric(DistanceMetric::CosineDistance);
    /// ```
    pub fn set_distance_metric<T: std::convert::Into<crate::model::DistanceMetric>>(
        mut self,
        v: T,
    ) -> Self {
        self.distance_metric = v.into();
        self
    }

    /// Sets the value of [index_field][crate::model::Index::index_field].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::Index;
    /// let x = Index::new().set_index_field("example");
    /// ```
    pub fn set_index_field<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.index_field = v.into();
        self
    }

    /// Sets the value of [filter_fields][crate::model::Index::filter_fields].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::Index;
    /// let x = Index::new().set_filter_fields(["a", "b", "c"]);
    /// ```
    pub fn set_filter_fields<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.filter_fields = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [store_fields][crate::model::Index::store_fields].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::Index;
    /// let x = Index::new().set_store_fields(["a", "b", "c"]);
    /// ```
    pub fn set_store_fields<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.store_fields = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [infra_type][crate::model::Index::infra_type].
    ///
    /// Note that all the setters affecting `infra_type` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::Index;
    /// use google_cloud_vectorsearch_v1::model::DedicatedInfrastructure;
    /// let x = Index::new().set_infra_type(Some(
    ///     google_cloud_vectorsearch_v1::model::index::InfraType::DedicatedInfrastructure(DedicatedInfrastructure::default().into())));
    /// ```
    pub fn set_infra_type<
        T: std::convert::Into<std::option::Option<crate::model::index::InfraType>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.infra_type = v.into();
        self
    }

    /// The value of [infra_type][crate::model::Index::infra_type]
    /// if it holds a `DedicatedInfrastructure`, `None` if the field is not set or
    /// holds a different branch.
    pub fn dedicated_infrastructure(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::DedicatedInfrastructure>> {
        #[allow(unreachable_patterns)]
        self.infra_type.as_ref().and_then(|v| match v {
            crate::model::index::InfraType::DedicatedInfrastructure(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [infra_type][crate::model::Index::infra_type]
    /// to hold a `DedicatedInfrastructure`.
    ///
    /// Note that all the setters affecting `infra_type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::Index;
    /// use google_cloud_vectorsearch_v1::model::DedicatedInfrastructure;
    /// let x = Index::new().set_dedicated_infrastructure(DedicatedInfrastructure::default()/* use setters */);
    /// assert!(x.dedicated_infrastructure().is_some());
    /// ```
    pub fn set_dedicated_infrastructure<
        T: std::convert::Into<std::boxed::Box<crate::model::DedicatedInfrastructure>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.infra_type = std::option::Option::Some(
            crate::model::index::InfraType::DedicatedInfrastructure(v.into()),
        );
        self
    }

    /// Sets the value of [index_type][crate::model::Index::index_type].
    ///
    /// Note that all the setters affecting `index_type` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::Index;
    /// use google_cloud_vectorsearch_v1::model::DenseScannIndex;
    /// let x = Index::new().set_index_type(Some(
    ///     google_cloud_vectorsearch_v1::model::index::IndexType::DenseScann(DenseScannIndex::default().into())));
    /// ```
    pub fn set_index_type<
        T: std::convert::Into<std::option::Option<crate::model::index::IndexType>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.index_type = v.into();
        self
    }

    /// The value of [index_type][crate::model::Index::index_type]
    /// if it holds a `DenseScann`, `None` if the field is not set or
    /// holds a different branch.
    pub fn dense_scann(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::DenseScannIndex>> {
        #[allow(unreachable_patterns)]
        self.index_type.as_ref().and_then(|v| match v {
            crate::model::index::IndexType::DenseScann(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [index_type][crate::model::Index::index_type]
    /// to hold a `DenseScann`.
    ///
    /// Note that all the setters affecting `index_type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::Index;
    /// use google_cloud_vectorsearch_v1::model::DenseScannIndex;
    /// let x = Index::new().set_dense_scann(DenseScannIndex::default()/* use setters */);
    /// assert!(x.dense_scann().is_some());
    /// ```
    pub fn set_dense_scann<
        T: std::convert::Into<std::boxed::Box<crate::model::DenseScannIndex>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.index_type =
            std::option::Option::Some(crate::model::index::IndexType::DenseScann(v.into()));
        self
    }
}

impl wkt::message::Message for Index {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.Index"
    }
}

/// Defines additional types related to [Index].
pub mod index {
    #[allow(unused_imports)]
    use super::*;

    /// The infrastructure type of the index.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum InfraType {
        /// Optional. Dedicated infrastructure for the index.
        DedicatedInfrastructure(std::boxed::Box<crate::model::DedicatedInfrastructure>),
    }

    /// The type of the index.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum IndexType {
        /// Optional. Dense ScaNN index.
        DenseScann(std::boxed::Box<crate::model::DenseScannIndex>),
    }
}

/// Message for creating an Index.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CreateIndexRequest {
    /// Required. The resource name of the Collection for which to create the
    /// Index. Format:
    /// `projects/{project}/locations/{location}/collections/{collection}`
    pub parent: std::string::String,

    /// Required. ID of the Index to create.
    /// The id must be 1-63 characters long, and comply with
    /// [RFC1035](https://www.ietf.org/rfc/rfc1035.txt).
    /// Specifically, it must be 1-63 characters long and match the regular
    /// expression `[a-z](?:[-a-z0-9]{0,61}[a-z0-9])?`.
    pub index_id: std::string::String,

    /// Required. The resource being created
    pub index: std::option::Option<crate::model::Index>,

    /// Optional. An optional request ID to identify requests. Specify a unique
    /// request ID so that if you must retry your request, the server will know to
    /// ignore the request if it has already been completed. The server will
    /// guarantee that for at least 60 minutes since the first request.
    ///
    /// For example, consider a situation where you make an initial request and the
    /// request times out. If you make the request again with the same request
    /// ID, the server can check if original operation with the same request ID
    /// was received, and if so, will ignore the second request. This prevents
    /// clients from accidentally creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID with the exception that zero UUID is
    /// not supported (00000000-0000-0000-0000-000000000000).
    pub request_id: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl CreateIndexRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::CreateIndexRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::CreateIndexRequest;
    /// let x = CreateIndexRequest::new().set_parent("example");
    /// ```
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [index_id][crate::model::CreateIndexRequest::index_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::CreateIndexRequest;
    /// let x = CreateIndexRequest::new().set_index_id("example");
    /// ```
    pub fn set_index_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.index_id = v.into();
        self
    }

    /// Sets the value of [index][crate::model::CreateIndexRequest::index].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::CreateIndexRequest;
    /// use google_cloud_vectorsearch_v1::model::Index;
    /// let x = CreateIndexRequest::new().set_index(Index::default()/* use setters */);
    /// ```
    pub fn set_index<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::Index>,
    {
        self.index = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [index][crate::model::CreateIndexRequest::index].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::CreateIndexRequest;
    /// use google_cloud_vectorsearch_v1::model::Index;
    /// let x = CreateIndexRequest::new().set_or_clear_index(Some(Index::default()/* use setters */));
    /// let x = CreateIndexRequest::new().set_or_clear_index(None::<Index>);
    /// ```
    pub fn set_or_clear_index<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::Index>,
    {
        self.index = v.map(|x| x.into());
        self
    }

    /// Sets the value of [request_id][crate::model::CreateIndexRequest::request_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::CreateIndexRequest;
    /// let x = CreateIndexRequest::new().set_request_id("example");
    /// ```
    pub fn set_request_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.request_id = v.into();
        self
    }
}

impl wkt::message::Message for CreateIndexRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.CreateIndexRequest"
    }
}

/// Message for deleting an Index.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DeleteIndexRequest {
    /// Required. The resource name of the Index to delete.
    /// Format:
    /// `projects/{project}/locations/{location}/collections/{collection}/indexes/{index}`
    pub name: std::string::String,

    /// Optional. An optional request ID to identify requests. Specify a unique
    /// request ID so that if you must retry your request, the server will know to
    /// ignore the request if it has already been completed. The server will
    /// guarantee that for at least 60 minutes since the first request.
    ///
    /// For example, consider a situation where you make an initial request and the
    /// request times out. If you make the request again with the same request
    /// ID, the server can check if original operation with the same request ID
    /// was received, and if so, will ignore the second request. This prevents
    /// clients from accidentally creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID with the exception that zero UUID is
    /// not supported (00000000-0000-0000-0000-000000000000).
    pub request_id: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl DeleteIndexRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::DeleteIndexRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::DeleteIndexRequest;
    /// let x = DeleteIndexRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [request_id][crate::model::DeleteIndexRequest::request_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::DeleteIndexRequest;
    /// let x = DeleteIndexRequest::new().set_request_id("example");
    /// ```
    pub fn set_request_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.request_id = v.into();
        self
    }
}

impl wkt::message::Message for DeleteIndexRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.DeleteIndexRequest"
    }
}

/// Message for requesting list of Indexes
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListIndexesRequest {
    /// Required. Parent value for ListIndexesRequest
    pub parent: std::string::String,

    /// Optional. Requested page size. Server may return fewer items than
    /// requested. If unspecified, server will pick an appropriate default.
    pub page_size: i32,

    /// Optional. A token identifying a page of results the server should return.
    pub page_token: std::string::String,

    /// Optional. Filtering results
    pub filter: std::string::String,

    /// Optional. Hint for how to order the results
    pub order_by: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ListIndexesRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::ListIndexesRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::ListIndexesRequest;
    /// let x = ListIndexesRequest::new().set_parent("example");
    /// ```
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [page_size][crate::model::ListIndexesRequest::page_size].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::ListIndexesRequest;
    /// let x = ListIndexesRequest::new().set_page_size(42);
    /// ```
    pub fn set_page_size<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.page_size = v.into();
        self
    }

    /// Sets the value of [page_token][crate::model::ListIndexesRequest::page_token].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::ListIndexesRequest;
    /// let x = ListIndexesRequest::new().set_page_token("example");
    /// ```
    pub fn set_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.page_token = v.into();
        self
    }

    /// Sets the value of [filter][crate::model::ListIndexesRequest::filter].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::ListIndexesRequest;
    /// let x = ListIndexesRequest::new().set_filter("example");
    /// ```
    pub fn set_filter<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.filter = v.into();
        self
    }

    /// Sets the value of [order_by][crate::model::ListIndexesRequest::order_by].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::ListIndexesRequest;
    /// let x = ListIndexesRequest::new().set_order_by("example");
    /// ```
    pub fn set_order_by<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.order_by = v.into();
        self
    }
}

impl wkt::message::Message for ListIndexesRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.ListIndexesRequest"
    }
}

/// Message for response to listing Indexes
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListIndexesResponse {
    /// The list of Index
    pub indexes: std::vec::Vec<crate::model::Index>,

    /// A token identifying a page of results the server should return.
    pub next_page_token: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ListIndexesResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [indexes][crate::model::ListIndexesResponse::indexes].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::ListIndexesResponse;
    /// use google_cloud_vectorsearch_v1::model::Index;
    /// let x = ListIndexesResponse::new()
    ///     .set_indexes([
    ///         Index::default()/* use setters */,
    ///         Index::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_indexes<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::Index>,
    {
        use std::iter::Iterator;
        self.indexes = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [next_page_token][crate::model::ListIndexesResponse::next_page_token].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::ListIndexesResponse;
    /// let x = ListIndexesResponse::new().set_next_page_token("example");
    /// ```
    pub fn set_next_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.next_page_token = v.into();
        self
    }
}

impl wkt::message::Message for ListIndexesResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.ListIndexesResponse"
    }
}

#[doc(hidden)]
impl google_cloud_gax::paginator::internal::PageableResponse for ListIndexesResponse {
    type PageItem = crate::model::Index;

    fn items(self) -> std::vec::Vec<Self::PageItem> {
        self.indexes
    }

    fn next_page_token(&self) -> std::string::String {
        use std::clone::Clone;
        self.next_page_token.clone()
    }
}

/// Message for getting an Index
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GetIndexRequest {
    /// Required. Name of the resource
    pub name: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl GetIndexRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::GetIndexRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::GetIndexRequest;
    /// let x = GetIndexRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for GetIndexRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.GetIndexRequest"
    }
}

/// Represents the metadata of the long-running operation.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct OperationMetadata {
    /// Output only. The time the operation was created.
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The time the operation finished running.
    pub end_time: std::option::Option<wkt::Timestamp>,

    /// Output only. Server-defined resource path for the target of the operation.
    pub target: std::string::String,

    /// Output only. Name of the verb executed by the operation.
    pub verb: std::string::String,

    /// Output only. Human-readable status of the operation, if any.
    pub status_message: std::string::String,

    /// Output only. Identifies whether the user has requested cancellation
    /// of the operation. Operations that have been cancelled successfully
    /// have
    /// [google.longrunning.Operation.error][google.longrunning.Operation.error]
    /// value with a [google.rpc.Status.code][google.rpc.Status.code] of `1`,
    /// corresponding to `Code.CANCELLED`.
    ///
    /// [google.longrunning.Operation.error]: google_cloud_longrunning::model::Operation::result
    /// [google.rpc.Status.code]: google_cloud_rpc::model::Status::code
    pub requested_cancellation: bool,

    /// Output only. API version used to start the operation.
    pub api_version: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl OperationMetadata {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [create_time][crate::model::OperationMetadata::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::OperationMetadata;
    /// use wkt::Timestamp;
    /// let x = OperationMetadata::new().set_create_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_create_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.create_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [create_time][crate::model::OperationMetadata::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::OperationMetadata;
    /// use wkt::Timestamp;
    /// let x = OperationMetadata::new().set_or_clear_create_time(Some(Timestamp::default()/* use setters */));
    /// let x = OperationMetadata::new().set_or_clear_create_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_create_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.create_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [end_time][crate::model::OperationMetadata::end_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::OperationMetadata;
    /// use wkt::Timestamp;
    /// let x = OperationMetadata::new().set_end_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_end_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.end_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [end_time][crate::model::OperationMetadata::end_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::OperationMetadata;
    /// use wkt::Timestamp;
    /// let x = OperationMetadata::new().set_or_clear_end_time(Some(Timestamp::default()/* use setters */));
    /// let x = OperationMetadata::new().set_or_clear_end_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_end_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.end_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [target][crate::model::OperationMetadata::target].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::OperationMetadata;
    /// let x = OperationMetadata::new().set_target("example");
    /// ```
    pub fn set_target<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.target = v.into();
        self
    }

    /// Sets the value of [verb][crate::model::OperationMetadata::verb].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::OperationMetadata;
    /// let x = OperationMetadata::new().set_verb("example");
    /// ```
    pub fn set_verb<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.verb = v.into();
        self
    }

    /// Sets the value of [status_message][crate::model::OperationMetadata::status_message].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::OperationMetadata;
    /// let x = OperationMetadata::new().set_status_message("example");
    /// ```
    pub fn set_status_message<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.status_message = v.into();
        self
    }

    /// Sets the value of [requested_cancellation][crate::model::OperationMetadata::requested_cancellation].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::OperationMetadata;
    /// let x = OperationMetadata::new().set_requested_cancellation(true);
    /// ```
    pub fn set_requested_cancellation<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.requested_cancellation = v.into();
        self
    }

    /// Sets the value of [api_version][crate::model::OperationMetadata::api_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::OperationMetadata;
    /// let x = OperationMetadata::new().set_api_version("example");
    /// ```
    pub fn set_api_version<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.api_version = v.into();
        self
    }
}

impl wkt::message::Message for OperationMetadata {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.OperationMetadata"
    }
}

/// Request message for
/// [VectorSearchService.ImportDataObjects][google.cloud.vectorsearch.v1.VectorSearchService.ImportDataObjects].
///
/// [google.cloud.vectorsearch.v1.VectorSearchService.ImportDataObjects]: crate::client::VectorSearchService::import_data_objects
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ImportDataObjectsRequest {
    /// Required. The resource name of the Collection to import DataObjects into.
    /// Format: `projects/{project}/locations/{location}/collections/{collection}`.
    pub name: std::string::String,

    /// The configuration for the import data and error results.
    pub config: std::option::Option<crate::model::import_data_objects_request::Config>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ImportDataObjectsRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::ImportDataObjectsRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::ImportDataObjectsRequest;
    /// let x = ImportDataObjectsRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [config][crate::model::ImportDataObjectsRequest::config].
    ///
    /// Note that all the setters affecting `config` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::ImportDataObjectsRequest;
    /// use google_cloud_vectorsearch_v1::model::import_data_objects_request::GcsImportConfig;
    /// let x = ImportDataObjectsRequest::new().set_config(Some(
    ///     google_cloud_vectorsearch_v1::model::import_data_objects_request::Config::GcsImport(GcsImportConfig::default().into())));
    /// ```
    pub fn set_config<
        T: std::convert::Into<std::option::Option<crate::model::import_data_objects_request::Config>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.config = v.into();
        self
    }

    /// The value of [config][crate::model::ImportDataObjectsRequest::config]
    /// if it holds a `GcsImport`, `None` if the field is not set or
    /// holds a different branch.
    pub fn gcs_import(
        &self,
    ) -> std::option::Option<
        &std::boxed::Box<crate::model::import_data_objects_request::GcsImportConfig>,
    > {
        #[allow(unreachable_patterns)]
        self.config.as_ref().and_then(|v| match v {
            crate::model::import_data_objects_request::Config::GcsImport(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [config][crate::model::ImportDataObjectsRequest::config]
    /// to hold a `GcsImport`.
    ///
    /// Note that all the setters affecting `config` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::ImportDataObjectsRequest;
    /// use google_cloud_vectorsearch_v1::model::import_data_objects_request::GcsImportConfig;
    /// let x = ImportDataObjectsRequest::new().set_gcs_import(GcsImportConfig::default()/* use setters */);
    /// assert!(x.gcs_import().is_some());
    /// ```
    pub fn set_gcs_import<
        T: std::convert::Into<
                std::boxed::Box<crate::model::import_data_objects_request::GcsImportConfig>,
            >,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.config = std::option::Option::Some(
            crate::model::import_data_objects_request::Config::GcsImport(v.into()),
        );
        self
    }
}

impl wkt::message::Message for ImportDataObjectsRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.ImportDataObjectsRequest"
    }
}

/// Defines additional types related to [ImportDataObjectsRequest].
pub mod import_data_objects_request {
    #[allow(unused_imports)]
    use super::*;

    /// Google Cloud Storage configuration for the import.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct GcsImportConfig {
        /// Required. URI prefix of the Cloud Storage DataObjects to import.
        pub contents_uri: std::string::String,

        /// Required. URI prefix of the Cloud Storage location to write any errors
        /// encountered during the import.
        pub error_uri: std::string::String,

        /// Optional. URI prefix of the Cloud Storage location to write DataObject
        /// `IDs` and `etags` of DataObjects that were successfully imported. The
        /// service will write the successfully imported DataObjects to sharded files
        /// under this prefix. If this field is empty, no output will be written.
        pub output_uri: std::string::String,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl GcsImportConfig {
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [contents_uri][crate::model::import_data_objects_request::GcsImportConfig::contents_uri].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_vectorsearch_v1::model::import_data_objects_request::GcsImportConfig;
        /// let x = GcsImportConfig::new().set_contents_uri("example");
        /// ```
        pub fn set_contents_uri<T: std::convert::Into<std::string::String>>(
            mut self,
            v: T,
        ) -> Self {
            self.contents_uri = v.into();
            self
        }

        /// Sets the value of [error_uri][crate::model::import_data_objects_request::GcsImportConfig::error_uri].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_vectorsearch_v1::model::import_data_objects_request::GcsImportConfig;
        /// let x = GcsImportConfig::new().set_error_uri("example");
        /// ```
        pub fn set_error_uri<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.error_uri = v.into();
            self
        }

        /// Sets the value of [output_uri][crate::model::import_data_objects_request::GcsImportConfig::output_uri].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_vectorsearch_v1::model::import_data_objects_request::GcsImportConfig;
        /// let x = GcsImportConfig::new().set_output_uri("example");
        /// ```
        pub fn set_output_uri<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.output_uri = v.into();
            self
        }
    }

    impl wkt::message::Message for GcsImportConfig {
        fn typename() -> &'static str {
            "type.googleapis.com/google.cloud.vectorsearch.v1.ImportDataObjectsRequest.GcsImportConfig"
        }
    }

    /// The configuration for the import data and error results.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Config {
        /// The Cloud Storage location of the input content.
        GcsImport(std::boxed::Box<crate::model::import_data_objects_request::GcsImportConfig>),
    }
}

/// Metadata for
/// [VectorSearchService.ImportDataObjects][google.cloud.vectorsearch.v1.VectorSearchService.ImportDataObjects].
///
/// [google.cloud.vectorsearch.v1.VectorSearchService.ImportDataObjects]: crate::client::VectorSearchService::import_data_objects
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ImportDataObjectsMetadata {
    /// Output only. The time the operation was created.
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The time the operation was last updated.
    pub update_time: std::option::Option<wkt::Timestamp>,

    /// Output only. Number of DataObjects that were processed successfully.
    pub success_count: i64,

    /// Output only. Number of DataObjects that failed during processing.
    pub failure_count: i64,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ImportDataObjectsMetadata {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [create_time][crate::model::ImportDataObjectsMetadata::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::ImportDataObjectsMetadata;
    /// use wkt::Timestamp;
    /// let x = ImportDataObjectsMetadata::new().set_create_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_create_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.create_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [create_time][crate::model::ImportDataObjectsMetadata::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::ImportDataObjectsMetadata;
    /// use wkt::Timestamp;
    /// let x = ImportDataObjectsMetadata::new().set_or_clear_create_time(Some(Timestamp::default()/* use setters */));
    /// let x = ImportDataObjectsMetadata::new().set_or_clear_create_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_create_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.create_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [update_time][crate::model::ImportDataObjectsMetadata::update_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::ImportDataObjectsMetadata;
    /// use wkt::Timestamp;
    /// let x = ImportDataObjectsMetadata::new().set_update_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_update_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.update_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [update_time][crate::model::ImportDataObjectsMetadata::update_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::ImportDataObjectsMetadata;
    /// use wkt::Timestamp;
    /// let x = ImportDataObjectsMetadata::new().set_or_clear_update_time(Some(Timestamp::default()/* use setters */));
    /// let x = ImportDataObjectsMetadata::new().set_or_clear_update_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_update_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.update_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [success_count][crate::model::ImportDataObjectsMetadata::success_count].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::ImportDataObjectsMetadata;
    /// let x = ImportDataObjectsMetadata::new().set_success_count(42);
    /// ```
    pub fn set_success_count<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
        self.success_count = v.into();
        self
    }

    /// Sets the value of [failure_count][crate::model::ImportDataObjectsMetadata::failure_count].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::ImportDataObjectsMetadata;
    /// let x = ImportDataObjectsMetadata::new().set_failure_count(42);
    /// ```
    pub fn set_failure_count<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
        self.failure_count = v.into();
        self
    }
}

impl wkt::message::Message for ImportDataObjectsMetadata {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.ImportDataObjectsMetadata"
    }
}

/// Response for
/// [VectorSearchService.ImportDataObjects][google.cloud.vectorsearch.v1.VectorSearchService.ImportDataObjects].
///
/// [google.cloud.vectorsearch.v1.VectorSearchService.ImportDataObjects]: crate::client::VectorSearchService::import_data_objects
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ImportDataObjectsResponse {
    /// Status of the LRO
    pub status: std::option::Option<google_cloud_rpc::model::Status>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ImportDataObjectsResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [status][crate::model::ImportDataObjectsResponse::status].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::ImportDataObjectsResponse;
    /// use google_cloud_rpc::model::Status;
    /// let x = ImportDataObjectsResponse::new().set_status(Status::default()/* use setters */);
    /// ```
    pub fn set_status<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_rpc::model::Status>,
    {
        self.status = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [status][crate::model::ImportDataObjectsResponse::status].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::ImportDataObjectsResponse;
    /// use google_cloud_rpc::model::Status;
    /// let x = ImportDataObjectsResponse::new().set_or_clear_status(Some(Status::default()/* use setters */));
    /// let x = ImportDataObjectsResponse::new().set_or_clear_status(None::<Status>);
    /// ```
    pub fn set_or_clear_status<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<google_cloud_rpc::model::Status>,
    {
        self.status = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for ImportDataObjectsResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.ImportDataObjectsResponse"
    }
}

/// Request message for
/// [VectorSearchService.ExportDataObjects][google.cloud.vectorsearch.v1.VectorSearchService.ExportDataObjects].
///
/// [google.cloud.vectorsearch.v1.VectorSearchService.ExportDataObjects]: crate::client::VectorSearchService::export_data_objects
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ExportDataObjectsRequest {
    /// Required. The resource name of the Collection from which we want to export
    /// Data Objects. Format:
    /// `projects/{project}/locations/{location}/collections/{collection}`.
    pub name: std::string::String,

    /// The configuration for the export data.
    pub destination: std::option::Option<crate::model::export_data_objects_request::Destination>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ExportDataObjectsRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::ExportDataObjectsRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::ExportDataObjectsRequest;
    /// let x = ExportDataObjectsRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [destination][crate::model::ExportDataObjectsRequest::destination].
    ///
    /// Note that all the setters affecting `destination` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::ExportDataObjectsRequest;
    /// use google_cloud_vectorsearch_v1::model::export_data_objects_request::GcsExportDestination;
    /// let x = ExportDataObjectsRequest::new().set_destination(Some(
    ///     google_cloud_vectorsearch_v1::model::export_data_objects_request::Destination::GcsDestination(GcsExportDestination::default().into())));
    /// ```
    pub fn set_destination<
        T: std::convert::Into<
                std::option::Option<crate::model::export_data_objects_request::Destination>,
            >,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.destination = v.into();
        self
    }

    /// The value of [destination][crate::model::ExportDataObjectsRequest::destination]
    /// if it holds a `GcsDestination`, `None` if the field is not set or
    /// holds a different branch.
    pub fn gcs_destination(
        &self,
    ) -> std::option::Option<
        &std::boxed::Box<crate::model::export_data_objects_request::GcsExportDestination>,
    > {
        #[allow(unreachable_patterns)]
        self.destination.as_ref().and_then(|v| match v {
            crate::model::export_data_objects_request::Destination::GcsDestination(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [destination][crate::model::ExportDataObjectsRequest::destination]
    /// to hold a `GcsDestination`.
    ///
    /// Note that all the setters affecting `destination` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::ExportDataObjectsRequest;
    /// use google_cloud_vectorsearch_v1::model::export_data_objects_request::GcsExportDestination;
    /// let x = ExportDataObjectsRequest::new().set_gcs_destination(GcsExportDestination::default()/* use setters */);
    /// assert!(x.gcs_destination().is_some());
    /// ```
    pub fn set_gcs_destination<
        T: std::convert::Into<
                std::boxed::Box<crate::model::export_data_objects_request::GcsExportDestination>,
            >,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.destination = std::option::Option::Some(
            crate::model::export_data_objects_request::Destination::GcsDestination(v.into()),
        );
        self
    }
}

impl wkt::message::Message for ExportDataObjectsRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.ExportDataObjectsRequest"
    }
}

/// Defines additional types related to [ExportDataObjectsRequest].
pub mod export_data_objects_request {
    #[allow(unused_imports)]
    use super::*;

    /// Google Cloud Storage configuration for the export.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct GcsExportDestination {
        /// Required. URI prefix of the Cloud Storage where to export Data Objects.
        /// The bucket is required to be in the same region as the collection.
        pub export_uri: std::string::String,

        /// Required. The format of the exported Data Objects.
        pub format: crate::model::export_data_objects_request::gcs_export_destination::Format,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl GcsExportDestination {
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [export_uri][crate::model::export_data_objects_request::GcsExportDestination::export_uri].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_vectorsearch_v1::model::export_data_objects_request::GcsExportDestination;
        /// let x = GcsExportDestination::new().set_export_uri("example");
        /// ```
        pub fn set_export_uri<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.export_uri = v.into();
            self
        }

        /// Sets the value of [format][crate::model::export_data_objects_request::GcsExportDestination::format].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_vectorsearch_v1::model::export_data_objects_request::GcsExportDestination;
        /// use google_cloud_vectorsearch_v1::model::export_data_objects_request::gcs_export_destination::Format;
        /// let x0 = GcsExportDestination::new().set_format(Format::Jsonl);
        /// ```
        pub fn set_format<
            T: std::convert::Into<
                    crate::model::export_data_objects_request::gcs_export_destination::Format,
                >,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.format = v.into();
            self
        }
    }

    impl wkt::message::Message for GcsExportDestination {
        fn typename() -> &'static str {
            "type.googleapis.com/google.cloud.vectorsearch.v1.ExportDataObjectsRequest.GcsExportDestination"
        }
    }

    /// Defines additional types related to [GcsExportDestination].
    pub mod gcs_export_destination {
        #[allow(unused_imports)]
        use super::*;

        /// Options for the format of the exported Data Objects.
        ///
        /// # Working with unknown values
        ///
        /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
        /// additional enum variants at any time. Adding new variants is not considered
        /// a breaking change. Applications should write their code in anticipation of:
        ///
        /// - New values appearing in future releases of the client library, **and**
        /// - New values received dynamically, without application changes.
        ///
        /// Please consult the [Working with enums] section in the user guide for some
        /// guidelines.
        ///
        /// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
        #[derive(Clone, Debug, PartialEq)]
        #[non_exhaustive]
        pub enum Format {
            /// Unspecified format.
            Unspecified,
            /// Exports Data Objects in `JSONL` format.
            Jsonl,
            /// If set, the enum was initialized with an unknown value.
            ///
            /// Applications can examine the value using [Format::value] or
            /// [Format::name].
            UnknownValue(format::UnknownValue),
        }

        #[doc(hidden)]
        pub mod format {
            #[allow(unused_imports)]
            use super::*;
            #[derive(Clone, Debug, PartialEq)]
            pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
        }

        impl Format {
            /// Gets the enum value.
            ///
            /// Returns `None` if the enum contains an unknown value deserialized from
            /// the string representation of enums.
            pub fn value(&self) -> std::option::Option<i32> {
                match self {
                    Self::Unspecified => std::option::Option::Some(0),
                    Self::Jsonl => std::option::Option::Some(2),
                    Self::UnknownValue(u) => u.0.value(),
                }
            }

            /// Gets the enum value as a string.
            ///
            /// Returns `None` if the enum contains an unknown value deserialized from
            /// the integer representation of enums.
            pub fn name(&self) -> std::option::Option<&str> {
                match self {
                    Self::Unspecified => std::option::Option::Some("FORMAT_UNSPECIFIED"),
                    Self::Jsonl => std::option::Option::Some("JSONL"),
                    Self::UnknownValue(u) => u.0.name(),
                }
            }
        }

        impl std::default::Default for Format {
            fn default() -> Self {
                use std::convert::From;
                Self::from(0)
            }
        }

        impl std::fmt::Display for Format {
            fn fmt(
                &self,
                f: &mut std::fmt::Formatter<'_>,
            ) -> std::result::Result<(), std::fmt::Error> {
                wkt::internal::display_enum(f, self.name(), self.value())
            }
        }

        impl std::convert::From<i32> for Format {
            fn from(value: i32) -> Self {
                match value {
                    0 => Self::Unspecified,
                    2 => Self::Jsonl,
                    _ => Self::UnknownValue(format::UnknownValue(
                        wkt::internal::UnknownEnumValue::Integer(value),
                    )),
                }
            }
        }

        impl std::convert::From<&str> for Format {
            fn from(value: &str) -> Self {
                use std::string::ToString;
                match value {
                    "FORMAT_UNSPECIFIED" => Self::Unspecified,
                    "JSONL" => Self::Jsonl,
                    _ => Self::UnknownValue(format::UnknownValue(
                        wkt::internal::UnknownEnumValue::String(value.to_string()),
                    )),
                }
            }
        }

        impl serde::ser::Serialize for Format {
            fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
            where
                S: serde::Serializer,
            {
                match self {
                    Self::Unspecified => serializer.serialize_i32(0),
                    Self::Jsonl => serializer.serialize_i32(2),
                    Self::UnknownValue(u) => u.0.serialize(serializer),
                }
            }
        }

        impl<'de> serde::de::Deserialize<'de> for Format {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                deserializer.deserialize_any(wkt::internal::EnumVisitor::<Format>::new(
                    ".google.cloud.vectorsearch.v1.ExportDataObjectsRequest.GcsExportDestination.Format"))
            }
        }
    }

    /// The configuration for the export data.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Destination {
        /// The Cloud Storage location where user wants to export Data Objects.
        GcsDestination(
            std::boxed::Box<crate::model::export_data_objects_request::GcsExportDestination>,
        ),
    }
}

/// Metadata for the ExportDataObjects LRO.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ExportDataObjectsMetadata {
    /// Output only. The time the operation was created.
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The time the operation finished.
    pub finish_time: std::option::Option<wkt::Timestamp>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ExportDataObjectsMetadata {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [create_time][crate::model::ExportDataObjectsMetadata::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::ExportDataObjectsMetadata;
    /// use wkt::Timestamp;
    /// let x = ExportDataObjectsMetadata::new().set_create_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_create_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.create_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [create_time][crate::model::ExportDataObjectsMetadata::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::ExportDataObjectsMetadata;
    /// use wkt::Timestamp;
    /// let x = ExportDataObjectsMetadata::new().set_or_clear_create_time(Some(Timestamp::default()/* use setters */));
    /// let x = ExportDataObjectsMetadata::new().set_or_clear_create_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_create_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.create_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [finish_time][crate::model::ExportDataObjectsMetadata::finish_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::ExportDataObjectsMetadata;
    /// use wkt::Timestamp;
    /// let x = ExportDataObjectsMetadata::new().set_finish_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_finish_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.finish_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [finish_time][crate::model::ExportDataObjectsMetadata::finish_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::ExportDataObjectsMetadata;
    /// use wkt::Timestamp;
    /// let x = ExportDataObjectsMetadata::new().set_or_clear_finish_time(Some(Timestamp::default()/* use setters */));
    /// let x = ExportDataObjectsMetadata::new().set_or_clear_finish_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_finish_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.finish_time = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for ExportDataObjectsMetadata {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.ExportDataObjectsMetadata"
    }
}

/// Response for the ExportDataObjects LRO.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ExportDataObjectsResponse {
    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ExportDataObjectsResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }
}

impl wkt::message::Message for ExportDataObjectsResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.ExportDataObjectsResponse"
    }
}

/// Represents dedicated infrastructure for the index.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DedicatedInfrastructure {
    /// Optional. Mode of the dedicated infrastructure.
    pub mode: std::option::Option<crate::model::dedicated_infrastructure::Mode>,

    /// Optional. Autoscaling specification.
    pub autoscaling_spec:
        std::option::Option<crate::model::dedicated_infrastructure::AutoscalingSpec>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl DedicatedInfrastructure {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [mode][crate::model::DedicatedInfrastructure::mode].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::DedicatedInfrastructure;
    /// use google_cloud_vectorsearch_v1::model::dedicated_infrastructure::Mode;
    /// let x0 = DedicatedInfrastructure::new().set_mode(Mode::StorageOptimized);
    /// let x1 = DedicatedInfrastructure::new().set_mode(Mode::PerformanceOptimized);
    /// ```
    pub fn set_mode<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::dedicated_infrastructure::Mode>,
    {
        self.mode = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [mode][crate::model::DedicatedInfrastructure::mode].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::DedicatedInfrastructure;
    /// use google_cloud_vectorsearch_v1::model::dedicated_infrastructure::Mode;
    /// let x0 = DedicatedInfrastructure::new().set_or_clear_mode(Some(Mode::StorageOptimized));
    /// let x1 = DedicatedInfrastructure::new().set_or_clear_mode(Some(Mode::PerformanceOptimized));
    /// let x_none = DedicatedInfrastructure::new().set_or_clear_mode(None::<Mode>);
    /// ```
    pub fn set_or_clear_mode<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::dedicated_infrastructure::Mode>,
    {
        self.mode = v.map(|x| x.into());
        self
    }

    /// Sets the value of [autoscaling_spec][crate::model::DedicatedInfrastructure::autoscaling_spec].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::DedicatedInfrastructure;
    /// use google_cloud_vectorsearch_v1::model::dedicated_infrastructure::AutoscalingSpec;
    /// let x = DedicatedInfrastructure::new().set_autoscaling_spec(AutoscalingSpec::default()/* use setters */);
    /// ```
    pub fn set_autoscaling_spec<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::dedicated_infrastructure::AutoscalingSpec>,
    {
        self.autoscaling_spec = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [autoscaling_spec][crate::model::DedicatedInfrastructure::autoscaling_spec].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::DedicatedInfrastructure;
    /// use google_cloud_vectorsearch_v1::model::dedicated_infrastructure::AutoscalingSpec;
    /// let x = DedicatedInfrastructure::new().set_or_clear_autoscaling_spec(Some(AutoscalingSpec::default()/* use setters */));
    /// let x = DedicatedInfrastructure::new().set_or_clear_autoscaling_spec(None::<AutoscalingSpec>);
    /// ```
    pub fn set_or_clear_autoscaling_spec<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::dedicated_infrastructure::AutoscalingSpec>,
    {
        self.autoscaling_spec = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for DedicatedInfrastructure {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.DedicatedInfrastructure"
    }
}

/// Defines additional types related to [DedicatedInfrastructure].
pub mod dedicated_infrastructure {
    #[allow(unused_imports)]
    use super::*;

    /// Specification for autoscaling.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct AutoscalingSpec {
        /// Optional. The minimum number of replicas. If not set or set to `0`,
        /// defaults to `2`. Must be >= `1` and <= `1000`.
        pub min_replica_count: i32,

        /// Optional. The maximum number of replicas.  Must be >=
        /// `min_replica_count` and <= `1000`.
        /// For the v1beta version, if not set or set to `0`, defaults to
        /// the greater of `min_replica_count` and `5`.
        /// For all other versions, if not set or set to `0`, defaults to
        /// the greater of `min_replica_count` and `2`.
        pub max_replica_count: i32,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl AutoscalingSpec {
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [min_replica_count][crate::model::dedicated_infrastructure::AutoscalingSpec::min_replica_count].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_vectorsearch_v1::model::dedicated_infrastructure::AutoscalingSpec;
        /// let x = AutoscalingSpec::new().set_min_replica_count(42);
        /// ```
        pub fn set_min_replica_count<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
            self.min_replica_count = v.into();
            self
        }

        /// Sets the value of [max_replica_count][crate::model::dedicated_infrastructure::AutoscalingSpec::max_replica_count].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_vectorsearch_v1::model::dedicated_infrastructure::AutoscalingSpec;
        /// let x = AutoscalingSpec::new().set_max_replica_count(42);
        /// ```
        pub fn set_max_replica_count<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
            self.max_replica_count = v.into();
            self
        }
    }

    impl wkt::message::Message for AutoscalingSpec {
        fn typename() -> &'static str {
            "type.googleapis.com/google.cloud.vectorsearch.v1.DedicatedInfrastructure.AutoscalingSpec"
        }
    }

    /// Mode of the dedicated infrastructure.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Mode {
        /// Default will use `PERFORMANCE_OPTIMIZED`.
        Unspecified,
        /// This is storage optimized variation.
        StorageOptimized,
        /// This is Performance optimized on E2 or equivalent family.
        PerformanceOptimized,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Mode::value] or
        /// [Mode::name].
        UnknownValue(mode::UnknownValue),
    }

    #[doc(hidden)]
    pub mod mode {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Mode {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::StorageOptimized => std::option::Option::Some(1),
                Self::PerformanceOptimized => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("MODE_UNSPECIFIED"),
                Self::StorageOptimized => std::option::Option::Some("STORAGE_OPTIMIZED"),
                Self::PerformanceOptimized => std::option::Option::Some("PERFORMANCE_OPTIMIZED"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Mode {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Mode {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Mode {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::StorageOptimized,
                2 => Self::PerformanceOptimized,
                _ => Self::UnknownValue(mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Mode {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "MODE_UNSPECIFIED" => Self::Unspecified,
                "STORAGE_OPTIMIZED" => Self::StorageOptimized,
                "PERFORMANCE_OPTIMIZED" => Self::PerformanceOptimized,
                _ => Self::UnknownValue(mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Mode {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::StorageOptimized => serializer.serialize_i32(1),
                Self::PerformanceOptimized => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Mode {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Mode>::new(
                ".google.cloud.vectorsearch.v1.DedicatedInfrastructure.Mode",
            ))
        }
    }
}

/// Dense ScaNN index configuration.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DenseScannIndex {
    /// Optional. Feature norm type.
    pub feature_norm_type: crate::model::dense_scann_index::FeatureNormType,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl DenseScannIndex {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [feature_norm_type][crate::model::DenseScannIndex::feature_norm_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_vectorsearch_v1::model::DenseScannIndex;
    /// use google_cloud_vectorsearch_v1::model::dense_scann_index::FeatureNormType;
    /// let x0 = DenseScannIndex::new().set_feature_norm_type(FeatureNormType::None);
    /// let x1 = DenseScannIndex::new().set_feature_norm_type(FeatureNormType::UnitL2Norm);
    /// ```
    pub fn set_feature_norm_type<
        T: std::convert::Into<crate::model::dense_scann_index::FeatureNormType>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.feature_norm_type = v.into();
        self
    }
}

impl wkt::message::Message for DenseScannIndex {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.vectorsearch.v1.DenseScannIndex"
    }
}

/// Defines additional types related to [DenseScannIndex].
pub mod dense_scann_index {
    #[allow(unused_imports)]
    use super::*;

    /// Feature norm type for ScaNN index.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum FeatureNormType {
        /// Unspecified feature norm type.
        Unspecified,
        /// No norm applied.
        None,
        /// Unit L2 norm.
        UnitL2Norm,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [FeatureNormType::value] or
        /// [FeatureNormType::name].
        UnknownValue(feature_norm_type::UnknownValue),
    }

    #[doc(hidden)]
    pub mod feature_norm_type {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl FeatureNormType {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::None => std::option::Option::Some(1),
                Self::UnitL2Norm => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("FEATURE_NORM_TYPE_UNSPECIFIED"),
                Self::None => std::option::Option::Some("NONE"),
                Self::UnitL2Norm => std::option::Option::Some("UNIT_L2_NORM"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for FeatureNormType {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for FeatureNormType {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for FeatureNormType {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::None,
                2 => Self::UnitL2Norm,
                _ => Self::UnknownValue(feature_norm_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for FeatureNormType {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "FEATURE_NORM_TYPE_UNSPECIFIED" => Self::Unspecified,
                "NONE" => Self::None,
                "UNIT_L2_NORM" => Self::UnitL2Norm,
                _ => Self::UnknownValue(feature_norm_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for FeatureNormType {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::None => serializer.serialize_i32(1),
                Self::UnitL2Norm => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for FeatureNormType {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<FeatureNormType>::new(
                ".google.cloud.vectorsearch.v1.DenseScannIndex.FeatureNormType",
            ))
        }
    }
}

/// Distance metric for vector search.
///
/// # Working with unknown values
///
/// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
/// additional enum variants at any time. Adding new variants is not considered
/// a breaking change. Applications should write their code in anticipation of:
///
/// - New values appearing in future releases of the client library, **and**
/// - New values received dynamically, without application changes.
///
/// Please consult the [Working with enums] section in the user guide for some
/// guidelines.
///
/// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum DistanceMetric {
    /// Default value, distance metric is not specified.
    Unspecified,
    /// Dot product distance metric.
    DotProduct,
    /// Cosine distance metric.
    CosineDistance,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [DistanceMetric::value] or
    /// [DistanceMetric::name].
    UnknownValue(distance_metric::UnknownValue),
}

#[doc(hidden)]
pub mod distance_metric {
    #[allow(unused_imports)]
    use super::*;
    #[derive(Clone, Debug, PartialEq)]
    pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
}

impl DistanceMetric {
    /// Gets the enum value.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the string representation of enums.
    pub fn value(&self) -> std::option::Option<i32> {
        match self {
            Self::Unspecified => std::option::Option::Some(0),
            Self::DotProduct => std::option::Option::Some(1),
            Self::CosineDistance => std::option::Option::Some(2),
            Self::UnknownValue(u) => u.0.value(),
        }
    }

    /// Gets the enum value as a string.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the integer representation of enums.
    pub fn name(&self) -> std::option::Option<&str> {
        match self {
            Self::Unspecified => std::option::Option::Some("DISTANCE_METRIC_UNSPECIFIED"),
            Self::DotProduct => std::option::Option::Some("DOT_PRODUCT"),
            Self::CosineDistance => std::option::Option::Some("COSINE_DISTANCE"),
            Self::UnknownValue(u) => u.0.name(),
        }
    }
}

impl std::default::Default for DistanceMetric {
    fn default() -> Self {
        use std::convert::From;
        Self::from(0)
    }
}

impl std::fmt::Display for DistanceMetric {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
        wkt::internal::display_enum(f, self.name(), self.value())
    }
}

impl std::convert::From<i32> for DistanceMetric {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::Unspecified,
            1 => Self::DotProduct,
            2 => Self::CosineDistance,
            _ => Self::UnknownValue(distance_metric::UnknownValue(
                wkt::internal::UnknownEnumValue::Integer(value),
            )),
        }
    }
}

impl std::convert::From<&str> for DistanceMetric {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "DISTANCE_METRIC_UNSPECIFIED" => Self::Unspecified,
            "DOT_PRODUCT" => Self::DotProduct,
            "COSINE_DISTANCE" => Self::CosineDistance,
            _ => Self::UnknownValue(distance_metric::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

impl serde::ser::Serialize for DistanceMetric {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        match self {
            Self::Unspecified => serializer.serialize_i32(0),
            Self::DotProduct => serializer.serialize_i32(1),
            Self::CosineDistance => serializer.serialize_i32(2),
            Self::UnknownValue(u) => u.0.serialize(serializer),
        }
    }
}

impl<'de> serde::de::Deserialize<'de> for DistanceMetric {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        deserializer.deserialize_any(wkt::internal::EnumVisitor::<DistanceMetric>::new(
            ".google.cloud.vectorsearch.v1.DistanceMetric",
        ))
    }
}

/// Aggregation methods.
///
/// # Working with unknown values
///
/// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
/// additional enum variants at any time. Adding new variants is not considered
/// a breaking change. Applications should write their code in anticipation of:
///
/// - New values appearing in future releases of the client library, **and**
/// - New values received dynamically, without application changes.
///
/// Please consult the [Working with enums] section in the user guide for some
/// guidelines.
///
/// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum AggregationMethod {
    /// Should not be used.
    Unspecified,
    /// Count the number of data objects that match the filter.
    Count,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [AggregationMethod::value] or
    /// [AggregationMethod::name].
    UnknownValue(aggregation_method::UnknownValue),
}

#[doc(hidden)]
pub mod aggregation_method {
    #[allow(unused_imports)]
    use super::*;
    #[derive(Clone, Debug, PartialEq)]
    pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
}

impl AggregationMethod {
    /// Gets the enum value.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the string representation of enums.
    pub fn value(&self) -> std::option::Option<i32> {
        match self {
            Self::Unspecified => std::option::Option::Some(0),
            Self::Count => std::option::Option::Some(1),
            Self::UnknownValue(u) => u.0.value(),
        }
    }

    /// Gets the enum value as a string.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the integer representation of enums.
    pub fn name(&self) -> std::option::Option<&str> {
        match self {
            Self::Unspecified => std::option::Option::Some("AGGREGATION_METHOD_UNSPECIFIED"),
            Self::Count => std::option::Option::Some("COUNT"),
            Self::UnknownValue(u) => u.0.name(),
        }
    }
}

impl std::default::Default for AggregationMethod {
    fn default() -> Self {
        use std::convert::From;
        Self::from(0)
    }
}

impl std::fmt::Display for AggregationMethod {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
        wkt::internal::display_enum(f, self.name(), self.value())
    }
}

impl std::convert::From<i32> for AggregationMethod {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::Unspecified,
            1 => Self::Count,
            _ => Self::UnknownValue(aggregation_method::UnknownValue(
                wkt::internal::UnknownEnumValue::Integer(value),
            )),
        }
    }
}

impl std::convert::From<&str> for AggregationMethod {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "AGGREGATION_METHOD_UNSPECIFIED" => Self::Unspecified,
            "COUNT" => Self::Count,
            _ => Self::UnknownValue(aggregation_method::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

impl serde::ser::Serialize for AggregationMethod {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        match self {
            Self::Unspecified => serializer.serialize_i32(0),
            Self::Count => serializer.serialize_i32(1),
            Self::UnknownValue(u) => u.0.serialize(serializer),
        }
    }
}

impl<'de> serde::de::Deserialize<'de> for AggregationMethod {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        deserializer.deserialize_any(wkt::internal::EnumVisitor::<AggregationMethod>::new(
            ".google.cloud.vectorsearch.v1.AggregationMethod",
        ))
    }
}

/// Represents the task the embeddings will be used for.
///
/// # Working with unknown values
///
/// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
/// additional enum variants at any time. Adding new variants is not considered
/// a breaking change. Applications should write their code in anticipation of:
///
/// - New values appearing in future releases of the client library, **and**
/// - New values received dynamically, without application changes.
///
/// Please consult the [Working with enums] section in the user guide for some
/// guidelines.
///
/// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum EmbeddingTaskType {
    /// Unspecified task type.
    Unspecified,
    /// Specifies the given text is a query in a search/retrieval setting.
    RetrievalQuery,
    /// Specifies the given text is a document from the corpus being searched.
    RetrievalDocument,
    /// Specifies the given text will be used for STS.
    SemanticSimilarity,
    /// Specifies that the given text will be classified.
    Classification,
    /// Specifies that the embeddings will be used for clustering.
    Clustering,
    /// Specifies that the embeddings will be used for question answering.
    QuestionAnswering,
    /// Specifies that the embeddings will be used for fact verification.
    FactVerification,
    /// Specifies that the embeddings will be used for code retrieval.
    CodeRetrievalQuery,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [EmbeddingTaskType::value] or
    /// [EmbeddingTaskType::name].
    UnknownValue(embedding_task_type::UnknownValue),
}

#[doc(hidden)]
pub mod embedding_task_type {
    #[allow(unused_imports)]
    use super::*;
    #[derive(Clone, Debug, PartialEq)]
    pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
}

impl EmbeddingTaskType {
    /// Gets the enum value.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the string representation of enums.
    pub fn value(&self) -> std::option::Option<i32> {
        match self {
            Self::Unspecified => std::option::Option::Some(0),
            Self::RetrievalQuery => std::option::Option::Some(1),
            Self::RetrievalDocument => std::option::Option::Some(2),
            Self::SemanticSimilarity => std::option::Option::Some(3),
            Self::Classification => std::option::Option::Some(4),
            Self::Clustering => std::option::Option::Some(5),
            Self::QuestionAnswering => std::option::Option::Some(6),
            Self::FactVerification => std::option::Option::Some(7),
            Self::CodeRetrievalQuery => std::option::Option::Some(8),
            Self::UnknownValue(u) => u.0.value(),
        }
    }

    /// Gets the enum value as a string.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the integer representation of enums.
    pub fn name(&self) -> std::option::Option<&str> {
        match self {
            Self::Unspecified => std::option::Option::Some("EMBEDDING_TASK_TYPE_UNSPECIFIED"),
            Self::RetrievalQuery => std::option::Option::Some("RETRIEVAL_QUERY"),
            Self::RetrievalDocument => std::option::Option::Some("RETRIEVAL_DOCUMENT"),
            Self::SemanticSimilarity => std::option::Option::Some("SEMANTIC_SIMILARITY"),
            Self::Classification => std::option::Option::Some("CLASSIFICATION"),
            Self::Clustering => std::option::Option::Some("CLUSTERING"),
            Self::QuestionAnswering => std::option::Option::Some("QUESTION_ANSWERING"),
            Self::FactVerification => std::option::Option::Some("FACT_VERIFICATION"),
            Self::CodeRetrievalQuery => std::option::Option::Some("CODE_RETRIEVAL_QUERY"),
            Self::UnknownValue(u) => u.0.name(),
        }
    }
}

impl std::default::Default for EmbeddingTaskType {
    fn default() -> Self {
        use std::convert::From;
        Self::from(0)
    }
}

impl std::fmt::Display for EmbeddingTaskType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
        wkt::internal::display_enum(f, self.name(), self.value())
    }
}

impl std::convert::From<i32> for EmbeddingTaskType {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::Unspecified,
            1 => Self::RetrievalQuery,
            2 => Self::RetrievalDocument,
            3 => Self::SemanticSimilarity,
            4 => Self::Classification,
            5 => Self::Clustering,
            6 => Self::QuestionAnswering,
            7 => Self::FactVerification,
            8 => Self::CodeRetrievalQuery,
            _ => Self::UnknownValue(embedding_task_type::UnknownValue(
                wkt::internal::UnknownEnumValue::Integer(value),
            )),
        }
    }
}

impl std::convert::From<&str> for EmbeddingTaskType {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "EMBEDDING_TASK_TYPE_UNSPECIFIED" => Self::Unspecified,
            "RETRIEVAL_QUERY" => Self::RetrievalQuery,
            "RETRIEVAL_DOCUMENT" => Self::RetrievalDocument,
            "SEMANTIC_SIMILARITY" => Self::SemanticSimilarity,
            "CLASSIFICATION" => Self::Classification,
            "CLUSTERING" => Self::Clustering,
            "QUESTION_ANSWERING" => Self::QuestionAnswering,
            "FACT_VERIFICATION" => Self::FactVerification,
            "CODE_RETRIEVAL_QUERY" => Self::CodeRetrievalQuery,
            _ => Self::UnknownValue(embedding_task_type::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

impl serde::ser::Serialize for EmbeddingTaskType {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        match self {
            Self::Unspecified => serializer.serialize_i32(0),
            Self::RetrievalQuery => serializer.serialize_i32(1),
            Self::RetrievalDocument => serializer.serialize_i32(2),
            Self::SemanticSimilarity => serializer.serialize_i32(3),
            Self::Classification => serializer.serialize_i32(4),
            Self::Clustering => serializer.serialize_i32(5),
            Self::QuestionAnswering => serializer.serialize_i32(6),
            Self::FactVerification => serializer.serialize_i32(7),
            Self::CodeRetrievalQuery => serializer.serialize_i32(8),
            Self::UnknownValue(u) => u.0.serialize(serializer),
        }
    }
}

impl<'de> serde::de::Deserialize<'de> for EmbeddingTaskType {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        deserializer.deserialize_any(wkt::internal::EnumVisitor::<EmbeddingTaskType>::new(
            ".google.cloud.vectorsearch.v1.EmbeddingTaskType",
        ))
    }
}