// This file is @generated by prost-build.
/// The HiveCatalog contains spark/hive databases and tables in the BigLake
/// Metastore. While creating resources under a catalog, ideally ensure that the
/// storage bucket location, spark / hive engine location or any other compute
/// location  match. Catalog can be viewed as the destination for migrating an
/// on-prem Hive metastore to GCP.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HiveCatalog {
    /// Output only. The resource name.
    /// Format:
    /// projects/{project_id_or_number}/catalogs/{catalog_id}
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. Stores the catalog description.
    /// The maximum length is 4000 characters.
    #[prost(string, tag = "2")]
    pub description: ::prost::alloc::string::String,
    /// Required. The Cloud Storage location path where the catalog exists.
    /// Format: gs://bucket/path/to/catalog
    /// The maximum length is 4000 characters.
    #[prost(string, tag = "3")]
    pub location_uri: ::prost::alloc::string::String,
    /// Output only. The replicas for the catalog metadata.
    #[prost(message, repeated, tag = "4")]
    pub replicas: ::prost::alloc::vec::Vec<hive_catalog::Replica>,
}
/// Nested message and enum types in `HiveCatalog`.
pub mod hive_catalog {
    /// The replica of the Catalog.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Replica {
        /// Output only. The region of the replica. For example `us-east1`.
        #[prost(string, tag = "1")]
        pub region: ::prost::alloc::string::String,
        /// Output only. The current state of the replica.
        #[prost(enumeration = "replica::State", tag = "2")]
        pub state: i32,
    }
    /// Nested message and enum types in `Replica`.
    pub mod replica {
        /// If the catalog is replicated to multiple regions, this enum describes the
        /// current state of the replica.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum State {
            /// The replica state is unknown.
            Unspecified = 0,
            /// Indicates the replica is the writable primary.
            Primary = 1,
            /// Indicates the replica has been recently assigned as the primary, but
            /// not all databases are writeable yet.
            PrimaryInProgress = 2,
            /// Indicates the replica is a read-only secondary replica.
            Secondary = 3,
        }
        impl State {
            /// String value of the enum field names used in the ProtoBuf definition.
            ///
            /// The values are not transformed in any way and thus are considered stable
            /// (if the ProtoBuf definition does not change) and safe for programmatic use.
            pub fn as_str_name(&self) -> &'static str {
                match self {
                    Self::Unspecified => "STATE_UNSPECIFIED",
                    Self::Primary => "STATE_PRIMARY",
                    Self::PrimaryInProgress => "STATE_PRIMARY_IN_PROGRESS",
                    Self::Secondary => "STATE_SECONDARY",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "STATE_UNSPECIFIED" => Some(Self::Unspecified),
                    "STATE_PRIMARY" => Some(Self::Primary),
                    "STATE_PRIMARY_IN_PROGRESS" => Some(Self::PrimaryInProgress),
                    "STATE_SECONDARY" => Some(Self::Secondary),
                    _ => None,
                }
            }
        }
    }
}
/// Request message for the CreateHiveCatalog method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateHiveCatalogRequest {
    /// Required. The parent resource where this catalog will be created.
    /// Format: projects/{project_id_or_number}
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The catalog to create.
    /// The `name` field does not need to be provided. Gets copied over from
    /// catalog_id.
    #[prost(message, optional, tag = "2")]
    pub hive_catalog: ::core::option::Option<HiveCatalog>,
    /// Required. The Hive Catalog ID to use for the catalog that will become the
    /// final component of the catalog's resource name. The maximum length is 256
    /// characters.
    #[prost(string, tag = "3")]
    pub hive_catalog_id: ::prost::alloc::string::String,
    /// Required. The GCP region that specifies where the catalog metadata is
    /// stored, e.g. us-central1, EU, etc.
    #[prost(string, tag = "4")]
    pub primary_location: ::prost::alloc::string::String,
}
/// Request message for the GetHiveCatalog method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetHiveCatalogRequest {
    /// Required. The name of the catalog to retrieve.
    /// Format:
    /// projects/{project_id_or_number}/catalogs/{catalog_id}
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for the ListHiveCatalogs method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListHiveCatalogsRequest {
    /// Required. The project to list catalogs from.
    /// Format: projects/{project_id_or_number}
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. Page size for pagination.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. Page token for pagination.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// Response message for the ListHiveCatalogs method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListHiveCatalogsResponse {
    /// Output only. The catalogs from the specified project.
    #[prost(message, repeated, tag = "1")]
    pub catalogs: ::prost::alloc::vec::Vec<HiveCatalog>,
    /// Output only. A token, which can be sent as `page_token` to retrieve the
    /// next page. If this field is omitted, there are no subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
    /// Output only. The list of unreachable cloud regions. If non-empty, the
    /// result set might be incomplete.
    #[prost(string, repeated, tag = "3")]
    pub unreachable: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Request message for the UpdateHiveCatalog method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateHiveCatalogRequest {
    /// Required. The hive catalog to update.
    /// The name under the catalog is used to identify the catalog.
    /// Format:
    /// projects/{project_id_or_number}/catalogs/{catalog_id}
    #[prost(message, optional, tag = "1")]
    pub hive_catalog: ::core::option::Option<HiveCatalog>,
    /// Optional. The list of fields to update.
    ///
    /// For the `FieldMask` definition, see
    /// <https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#fieldmask>
    /// If not set, defaults to all of the fields that are allowed to update.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request message for the DeleteHiveCatalog method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteHiveCatalogRequest {
    /// Required. The name of the catalog to delete.
    /// Format:
    /// projects/{project_id_or_number}/catalogs/{catalog_id}
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Stores the hive database information. It includes the database name,
/// description, location and properties associated with the database.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HiveDatabase {
    /// Output only. The resource name.
    /// Format:
    /// projects/{project_id_or_number}/catalogs/{catalog_id}/databases/{database_id}
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. Stores the database description.
    /// The maximum length is 4000 characters.
    #[prost(string, tag = "2")]
    pub description: ::prost::alloc::string::String,
    /// Optional. The Cloud Storage location path where the database exists.
    /// Format: `gs://bucket/path/to/database`
    /// If unspecified, the database will be stored in the catalog location.
    /// The maximum length is 4000 characters.
    #[prost(string, tag = "3")]
    pub location_uri: ::prost::alloc::string::String,
    /// Optional. Stores the properties associated with the database.
    /// The maximum size is 2 MiB.
    #[prost(map = "string, string", tag = "4")]
    pub parameters: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
/// Request message for the CreateHiveDatabase method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateHiveDatabaseRequest {
    /// Required. The parent resource where this database will be created.
    /// Format:
    /// projects/{project_id_or_number}/catalogs/{catalog_id}
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The database to create.
    /// The `name` field does not need to be provided.
    #[prost(message, optional, tag = "2")]
    pub hive_database: ::core::option::Option<HiveDatabase>,
    /// Required. The ID to use for the Hive Database.
    /// The maximum length is 128 characters.
    #[prost(string, tag = "3")]
    pub hive_database_id: ::prost::alloc::string::String,
}
/// Request message for the GetHiveDatabase method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetHiveDatabaseRequest {
    /// Required. The name of the database to retrieve.
    /// Format:
    /// projects/{project_id_or_number}/catalogs/{catalog_id}/databases/{database_id}
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for the ListHiveDatabases method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListHiveDatabasesRequest {
    /// Required. The hive catalog to list databases from.
    /// Format: projects/{project_id_or_number}/catalogs/{catalog_id}
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. Page size for pagination.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. PageToken for pagination.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// Response message for the ListHiveDatabases method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListHiveDatabasesResponse {
    /// Output only. The databases from the specified project and catalog.
    #[prost(message, repeated, tag = "1")]
    pub databases: ::prost::alloc::vec::Vec<HiveDatabase>,
    /// Output only. A token, which can be sent as `page_token` to retrieve the
    /// next page. If this field is omitted, there are no subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for the UpdateHiveDatabase method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateHiveDatabaseRequest {
    /// Required. The database to update.
    ///
    /// The database's `name` field is used to identify the database to update.
    /// Format:
    /// projects/{project_id_or_number}/catalogs/{catalog_id}/databases/{database_id}
    #[prost(message, optional, tag = "1")]
    pub hive_database: ::core::option::Option<HiveDatabase>,
    /// Optional. The list of fields to update.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request message for the DeleteHiveDatabase method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteHiveDatabaseRequest {
    /// Required. The name of the database to delete.
    /// Format:
    /// projects/{project_id_or_number}/catalogs/{catalog_id}/databases/{database_id}
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Stores the hive table information. It includes the table name, schema (column
/// names and types), data location, storage format, serde info, etc. This
/// message closely matches the Table object in the IMetastoreClient
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HiveTable {
    /// Output only. The resource name.
    /// Format:
    /// projects/{project_id_or_number}/catalogs/{catalog_id}/databases/{database_id}/tables/{table_id}
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. Description of the table. The maximum length is 4000 characters.
    #[prost(string, tag = "2")]
    pub description: ::prost::alloc::string::String,
    /// Required. Storage descriptor of the table.
    #[prost(message, optional, tag = "3")]
    pub storage_descriptor: ::core::option::Option<StorageDescriptor>,
    /// Output only. The creation time of the table.
    #[prost(message, optional, tag = "4")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Optional. The partition keys of the table.
    #[prost(message, repeated, tag = "7")]
    pub partition_keys: ::prost::alloc::vec::Vec<FieldSchema>,
    /// Optional. Stores the properties associated with the table. The maximum size
    /// is 4MiB.
    #[prost(map = "string, string", tag = "8")]
    pub parameters: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Output only. The type of the table. This is EXTERNAL for BigLake hive
    /// tables.
    #[prost(string, tag = "11")]
    pub table_type: ::prost::alloc::string::String,
}
/// Field schema information.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FieldSchema {
    /// Required. Name of the field. The maximum length is 767 characters.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. Type of the field. The maximum length is 128 characters.
    #[prost(string, tag = "2")]
    pub r#type: ::prost::alloc::string::String,
    /// Optional. Comment of the field. The maximum length is 256 characters.
    #[prost(string, tag = "3")]
    pub comment: ::prost::alloc::string::String,
}
/// Contains information about the physical storage of the table data.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StorageDescriptor {
    /// Required. Specifies the columns of the table.
    #[prost(message, repeated, tag = "1")]
    pub columns: ::prost::alloc::vec::Vec<FieldSchema>,
    /// Optional. The Cloud storage uri where the table is located.
    /// Defaults to `<database_location_uri>/<table_name>`. The maximum length is
    /// 4000 characters.
    #[prost(string, tag = "2")]
    pub location_uri: ::prost::alloc::string::String,
    /// Optional. The fully qualified Java class name of the input format. The
    /// maximum length is 4000 characters.
    #[prost(string, tag = "3")]
    pub input_format: ::prost::alloc::string::String,
    /// Optional. The fully qualified Java class name of the output format. The
    /// maximum length is 4000 characters.
    #[prost(string, tag = "4")]
    pub output_format: ::prost::alloc::string::String,
    /// Optional. Whether the table is compressed.
    #[prost(bool, optional, tag = "5")]
    pub compressed: ::core::option::Option<bool>,
    /// Optional. The number of buckets in the table.
    #[prost(int32, optional, tag = "6")]
    pub num_buckets: ::core::option::Option<i32>,
    /// Optional. Serialization and deserialization information.
    #[prost(message, optional, tag = "7")]
    pub serde_info: ::core::option::Option<SerdeInfo>,
    /// Optional. Reducer grouping columns and clustering columns and bucketing
    /// columns
    #[prost(string, repeated, tag = "8")]
    pub bucket_cols: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. Sort order of the data in each bucket
    #[prost(message, repeated, tag = "9")]
    pub sort_cols: ::prost::alloc::vec::Vec<storage_descriptor::Order>,
    /// Optional. Key-value pairs for the storage descriptor. The maximum size is
    /// 10Kib.
    #[prost(map = "string, string", tag = "10")]
    pub parameters: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Optional. Table data skew information.
    #[prost(message, optional, tag = "11")]
    pub skewed_info: ::core::option::Option<storage_descriptor::SkewedInfo>,
    /// Optional. Whether the table is stored as sub directories.
    #[prost(bool, optional, tag = "12")]
    pub stored_as_sub_dirs: ::core::option::Option<bool>,
}
/// Nested message and enum types in `StorageDescriptor`.
pub mod storage_descriptor {
    /// Sort order of the stored data per column.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Order {
        /// Required. The column name. The maximum length is 767 characters.
        #[prost(string, tag = "1")]
        pub col: ::prost::alloc::string::String,
        /// Required. Defines the sort order of the column. Ascending if 1,
        /// descending if 0.
        #[prost(int32, tag = "2")]
        pub order: i32,
    }
    /// Stores all the information about skewed table.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct SkewedInfo {
        /// Required. The column names that are skewed. The maximum length is 256
        /// characters per column name.
        #[prost(string, repeated, tag = "1")]
        pub skewed_col_names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
        /// Required. The skewed column values.
        #[prost(message, repeated, tag = "2")]
        pub skewed_col_values: ::prost::alloc::vec::Vec<skewed_info::SkewedColumnValue>,
        /// Required. The skewed key values locations.
        #[prost(message, repeated, tag = "3")]
        pub skewed_key_values_locations: ::prost::alloc::vec::Vec<
            skewed_info::SkewedKeyValuesLocation,
        >,
    }
    /// Nested message and enum types in `SkewedInfo`.
    pub mod skewed_info {
        /// The skewed column values.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct SkewedColumnValue {
            /// Required. The skewed column values. The maximum length is 256
            /// characters per value.
            #[prost(string, repeated, tag = "1")]
            pub values: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
        }
        /// The skewed key values and their corresponding location.
        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct SkewedKeyValuesLocation {
            /// Required. The skewed column values. The maximum length is 256
            /// characters per value.
            #[prost(string, repeated, tag = "1")]
            pub values: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
            /// Required. The location of the skewed column values. The maximum length
            /// is 4000 characters.
            #[prost(string, tag = "2")]
            pub location: ::prost::alloc::string::String,
        }
    }
}
/// Serialization and deserialization information.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SerdeInfo {
    /// Required. Name of the SerDe. Table name by default. The maximum length is
    /// 128 characters.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Required. The fully qualified Java class name of the serialization library.
    /// The maximum length is 4000 characters.
    #[prost(string, tag = "2")]
    pub serialization_lib: ::prost::alloc::string::String,
    /// Optional. Description of the serde. The maximum length is 4000 characters.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Optional. Parameters of the serde. The maximum size is 10Kib.
    #[prost(map = "string, string", tag = "4")]
    pub parameters: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Optional. The fully qualified Java class name of the serializer. The
    /// maximum length is 4000 characters.
    #[prost(string, tag = "5")]
    pub serializer_class: ::prost::alloc::string::String,
    /// Optional. The fully qualified Java class name of the deserializer. The
    /// maximum length is 4000 characters.
    #[prost(string, tag = "6")]
    pub deserializer_class: ::prost::alloc::string::String,
    /// Optional. The serde type.
    #[prost(enumeration = "serde_info::SerdeType", tag = "7")]
    pub serde_type: i32,
}
/// Nested message and enum types in `SerdeInfo`.
pub mod serde_info {
    /// The serde types.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum SerdeType {
        /// The serde type is not specified.
        Unspecified = 0,
        /// Hive.
        Hive = 1,
        /// Schema registry.
        SchemaRegistry = 2,
    }
    impl SerdeType {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "SERDE_TYPE_UNSPECIFIED",
                Self::Hive => "HIVE",
                Self::SchemaRegistry => "SCHEMA_REGISTRY",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "SERDE_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "HIVE" => Some(Self::Hive),
                "SCHEMA_REGISTRY" => Some(Self::SchemaRegistry),
                _ => None,
            }
        }
    }
}
/// Request message for the CreateHiveTable method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateHiveTableRequest {
    /// Required. The parent resource for the table to be created.
    /// Format:
    /// projects/{project_id_or_number}/catalogs/{catalog_id}/databases/{database_id}
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The Hive Table to create.
    /// The `name` field does not need to be provided.
    #[prost(message, optional, tag = "2")]
    pub hive_table: ::core::option::Option<HiveTable>,
    /// Required. The Hive Table ID to use for the table that will become the final
    /// component of the table's resource name. The maximum length is 256
    /// characters.
    #[prost(string, tag = "3")]
    pub hive_table_id: ::prost::alloc::string::String,
}
/// Request message for the GetHiveTable method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetHiveTableRequest {
    /// Required. The name of the table to retrieve.
    /// Format:
    /// projects/{project_id_or_number}/catalogs/{catalog_id}/databases/{database_id}/tables/{table_id}
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for the ListHiveTables method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListHiveTablesRequest {
    /// Required. The database to list tables from.
    /// Format:
    /// projects/{project_id_or_number}/catalogs/{catalog_id}/databases/{database_id}
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. Page size for pagination.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. PageToken for pagination.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// Response message for the ListHiveTables method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListHiveTablesResponse {
    /// Output only. The tables from the specified project, catalog and database.
    #[prost(message, repeated, tag = "1")]
    pub tables: ::prost::alloc::vec::Vec<HiveTable>,
    /// Output only. A token, which can be sent as `page_token` to retrieve the
    /// next page. If this field is omitted, there are no subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for the UpdateHiveTable method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateHiveTableRequest {
    /// Required. The table to update.
    ///
    /// The table's `name` field is used to identify the table to update.
    /// Format:
    /// projects/{project_id_or_number}/catalogs/{catalog_id}/databases/{database_id}/tables/{table_id}
    #[prost(message, optional, tag = "1")]
    pub hive_table: ::core::option::Option<HiveTable>,
    /// Optional. The list of fields to update.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request message for the DeleteHiveTable method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteHiveTableRequest {
    /// Required. The name of the database to delete.
    /// Format:
    /// projects/{project_id_or_number}/catalogs/{catalog_id}/databases/{database_id}/tables/{table_id}
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Information about a Hive partition.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Partition {
    /// Required. Represents the values of the partition keys, where each value
    /// corresponds to a specific partition key in the order in which the keys are
    /// defined. Each value is limited to 1024 characters.
    #[prost(string, repeated, tag = "1")]
    pub values: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Output only. The creation time of the partition.
    #[prost(message, optional, tag = "2")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Optional. Contains information about the physical storage of the data in
    /// the partition.
    #[prost(message, optional, tag = "3")]
    pub storage_descriptor: ::core::option::Option<StorageDescriptor>,
    /// Optional. Additional parameters or metadata associated with the partition.
    /// Maximum size 10 KiB.
    #[prost(map = "string, string", tag = "4")]
    pub parameters: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Optional. List of columns.
    #[prost(message, repeated, tag = "5")]
    pub fields: ::prost::alloc::vec::Vec<FieldSchema>,
}
/// Represents the values of a partition.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PartitionValues {
    /// Required. The values of the partition keys, where each value corresponds to
    /// a specific partition key in the order in which the keys are defined.
    #[prost(string, repeated, tag = "1")]
    pub values: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Request message for CreatePartition. The Partition is
/// uniquely identified by values, which is an ordered list. Hence, there is no
/// separate name or partition id field.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreatePartitionRequest {
    /// Required. Reference to the table to where the partition to be added, in the
    /// format of
    /// projects/{project}/catalogs/{catalogs}/databases/{databases}/tables/{table}.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The partition to be added.
    #[prost(message, optional, tag = "2")]
    pub partition: ::core::option::Option<Partition>,
}
/// Request message for the BatchCreatePartitions method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchCreatePartitionsRequest {
    /// Required. Reference to the table to where the partitions to be added, in
    /// the format of
    /// projects/{project}/catalogs/{catalogs}/databases/{database}/tables/{table}.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. Requests to add partitions to the table.
    #[prost(message, repeated, tag = "2")]
    pub requests: ::prost::alloc::vec::Vec<CreatePartitionRequest>,
    /// Optional. Corresponds to the `ifNotExists` flag in the Hive Metastore APIs.
    /// If the flag is set to false, the server will return ALREADY_EXISTS if any
    /// partition already exists. If the flag is set to true, the server will skip
    /// existing partitions and insert only the non-existing partitions.
    /// A maximum of 900 partitions can be inserted in a batch.
    #[prost(bool, tag = "3")]
    pub skip_existing_partitions: bool,
}
/// Response message for BatchCreatePartitions.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchCreatePartitionsResponse {
    /// The list of partitions that have been added.
    #[prost(message, repeated, tag = "1")]
    pub partitions: ::prost::alloc::vec::Vec<Partition>,
}
/// Request message for BatchDeletePartitions. The Partition is
/// uniquely identified by values, which is an ordered list. Hence, there is no
/// separate name or partition id field.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchDeletePartitionsRequest {
    /// Required. Reference to the table to which these partitions belong, in the
    /// format of
    /// projects/{project}/catalogs/{catalogs}/databases/{database}/tables/{table}.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The list of partitions (identified by its values) to be deleted.
    /// A maximum of 900 partitions can be deleted in a batch.
    #[prost(message, repeated, tag = "2")]
    pub partition_values: ::prost::alloc::vec::Vec<PartitionValues>,
}
/// Request message for UpdatePartition.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdatePartitionRequest {
    /// Required. The partition to be updated.
    #[prost(message, optional, tag = "1")]
    pub partition: ::core::option::Option<Partition>,
    /// Optional. The list of fields to update.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request message for BatchUpdatePartitions.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchUpdatePartitionsRequest {
    /// Required. Reference to the table to which these partitions belong, in the
    /// format of
    /// projects/{project}/catalogs/{catalogs}/databases/{database}/tables/{table}.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. Requests to update partitions in the table.
    #[prost(message, repeated, tag = "2")]
    pub requests: ::prost::alloc::vec::Vec<UpdatePartitionRequest>,
}
/// Response message for BatchUpdatePartitions.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchUpdatePartitionsResponse {
    /// The list of partitions that have been updated.
    /// A maximum of 900 partitions can be updated in a batch.
    #[prost(message, repeated, tag = "1")]
    pub partitions: ::prost::alloc::vec::Vec<Partition>,
}
/// Request message for ListPartitions.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListPartitionsRequest {
    /// Required. Reference to the table to which these partitions belong, in the
    /// format of
    /// projects/{project}/catalogs/{catalogs}/databases/{database}/tables/{table}.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. SQL text filtering statement, similar to a `WHERE` clause in a
    /// query. Only supports single-row expressions.  Aggregate functions are not
    /// supported.
    ///
    /// Examples:
    ///
    /// * `"int_field > 5"`
    /// * `"date_field = CAST('2014-9-27' as DATE)"`
    /// * `"nullable_field is not NULL"`
    /// * `"st_equals(geo_field, st_geofromtext("POINT(2, 2)"))"`
    /// * `"numeric_field BETWEEN 1.0 AND 5.0"`
    ///
    /// Restricted to a maximum length of 1 MB.
    #[prost(string, tag = "2")]
    pub filter: ::prost::alloc::string::String,
}
/// Response message for ListPartitions.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListPartitionsResponse {
    /// Output only. List of partitions.
    #[prost(message, repeated, tag = "1")]
    pub partitions: ::prost::alloc::vec::Vec<Partition>,
}
/// Generated client implementations.
pub mod hive_metastore_service_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Hive Metastore Service is a biglake service that allows users to manage
    /// their external Hive catalogs. Full API compatibility with OSS Hive Metastore
    /// APIs is not supported. The methods match the Hive Metastore API spec mostly
    /// except for a few exceptions.
    /// These include listing resources with pattern,
    /// environment context which are combined in a single List API, return of
    /// ListResponse object instead of a list of resources, transactions, locks, etc.
    ///
    /// The BigLake Hive Metastore API defines the following resources:
    ///
    /// * A collection of Google Cloud projects: `/projects/*`
    /// * Each project has a collection of catalogs: `/catalogs/*`
    /// * Each catalog has a collection of databases: `/databases/*`
    /// * Each database has a collection of tables: `/tables/*`
    #[derive(Debug, Clone)]
    pub struct HiveMetastoreServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl HiveMetastoreServiceClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> HiveMetastoreServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::Body>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> HiveMetastoreServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::Body>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::Body>,
            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            HiveMetastoreServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Creates a new hive catalog.
        pub async fn create_hive_catalog(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateHiveCatalogRequest>,
        ) -> std::result::Result<tonic::Response<super::HiveCatalog>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.biglake.hive.v1beta.HiveMetastoreService/CreateHiveCatalog",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.biglake.hive.v1beta.HiveMetastoreService",
                        "CreateHiveCatalog",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets the catalog specified by the resource name.
        pub async fn get_hive_catalog(
            &mut self,
            request: impl tonic::IntoRequest<super::GetHiveCatalogRequest>,
        ) -> std::result::Result<tonic::Response<super::HiveCatalog>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.biglake.hive.v1beta.HiveMetastoreService/GetHiveCatalog",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.biglake.hive.v1beta.HiveMetastoreService",
                        "GetHiveCatalog",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// List all catalogs in a specified project.
        pub async fn list_hive_catalogs(
            &mut self,
            request: impl tonic::IntoRequest<super::ListHiveCatalogsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListHiveCatalogsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.biglake.hive.v1beta.HiveMetastoreService/ListHiveCatalogs",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.biglake.hive.v1beta.HiveMetastoreService",
                        "ListHiveCatalogs",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates an existing catalog.
        pub async fn update_hive_catalog(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateHiveCatalogRequest>,
        ) -> std::result::Result<tonic::Response<super::HiveCatalog>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.biglake.hive.v1beta.HiveMetastoreService/UpdateHiveCatalog",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.biglake.hive.v1beta.HiveMetastoreService",
                        "UpdateHiveCatalog",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes an existing catalog specified by the catalog ID. Delete will fail
        /// if the catalog is not empty.
        pub async fn delete_hive_catalog(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteHiveCatalogRequest>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.biglake.hive.v1beta.HiveMetastoreService/DeleteHiveCatalog",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.biglake.hive.v1beta.HiveMetastoreService",
                        "DeleteHiveCatalog",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a new database.
        pub async fn create_hive_database(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateHiveDatabaseRequest>,
        ) -> std::result::Result<tonic::Response<super::HiveDatabase>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.biglake.hive.v1beta.HiveMetastoreService/CreateHiveDatabase",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.biglake.hive.v1beta.HiveMetastoreService",
                        "CreateHiveDatabase",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets the database specified by the resource name.
        pub async fn get_hive_database(
            &mut self,
            request: impl tonic::IntoRequest<super::GetHiveDatabaseRequest>,
        ) -> std::result::Result<tonic::Response<super::HiveDatabase>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.biglake.hive.v1beta.HiveMetastoreService/GetHiveDatabase",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.biglake.hive.v1beta.HiveMetastoreService",
                        "GetHiveDatabase",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// List all databases in a specified catalog.
        pub async fn list_hive_databases(
            &mut self,
            request: impl tonic::IntoRequest<super::ListHiveDatabasesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListHiveDatabasesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.biglake.hive.v1beta.HiveMetastoreService/ListHiveDatabases",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.biglake.hive.v1beta.HiveMetastoreService",
                        "ListHiveDatabases",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates an existing database specified by the database name.
        pub async fn update_hive_database(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateHiveDatabaseRequest>,
        ) -> std::result::Result<tonic::Response<super::HiveDatabase>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.biglake.hive.v1beta.HiveMetastoreService/UpdateHiveDatabase",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.biglake.hive.v1beta.HiveMetastoreService",
                        "UpdateHiveDatabase",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes an existing database specified by the database name.
        pub async fn delete_hive_database(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteHiveDatabaseRequest>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.biglake.hive.v1beta.HiveMetastoreService/DeleteHiveDatabase",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.biglake.hive.v1beta.HiveMetastoreService",
                        "DeleteHiveDatabase",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a new hive table.
        pub async fn create_hive_table(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateHiveTableRequest>,
        ) -> std::result::Result<tonic::Response<super::HiveTable>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.biglake.hive.v1beta.HiveMetastoreService/CreateHiveTable",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.biglake.hive.v1beta.HiveMetastoreService",
                        "CreateHiveTable",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets the table specified by the resource name.
        pub async fn get_hive_table(
            &mut self,
            request: impl tonic::IntoRequest<super::GetHiveTableRequest>,
        ) -> std::result::Result<tonic::Response<super::HiveTable>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.biglake.hive.v1beta.HiveMetastoreService/GetHiveTable",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.biglake.hive.v1beta.HiveMetastoreService",
                        "GetHiveTable",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// List all hive tables in a specified project under the hive catalog and
        /// database.
        pub async fn list_hive_tables(
            &mut self,
            request: impl tonic::IntoRequest<super::ListHiveTablesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListHiveTablesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.biglake.hive.v1beta.HiveMetastoreService/ListHiveTables",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.biglake.hive.v1beta.HiveMetastoreService",
                        "ListHiveTables",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates an existing table specified by the table name.
        pub async fn update_hive_table(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateHiveTableRequest>,
        ) -> std::result::Result<tonic::Response<super::HiveTable>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.biglake.hive.v1beta.HiveMetastoreService/UpdateHiveTable",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.biglake.hive.v1beta.HiveMetastoreService",
                        "UpdateHiveTable",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes an existing table specified by the table name.
        pub async fn delete_hive_table(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteHiveTableRequest>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.biglake.hive.v1beta.HiveMetastoreService/DeleteHiveTable",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.biglake.hive.v1beta.HiveMetastoreService",
                        "DeleteHiveTable",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Adds partitions to a table.
        pub async fn batch_create_partitions(
            &mut self,
            request: impl tonic::IntoRequest<super::BatchCreatePartitionsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::BatchCreatePartitionsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.biglake.hive.v1beta.HiveMetastoreService/BatchCreatePartitions",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.biglake.hive.v1beta.HiveMetastoreService",
                        "BatchCreatePartitions",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes partitions from a table.
        pub async fn batch_delete_partitions(
            &mut self,
            request: impl tonic::IntoRequest<super::BatchDeletePartitionsRequest>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.biglake.hive.v1beta.HiveMetastoreService/BatchDeletePartitions",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.biglake.hive.v1beta.HiveMetastoreService",
                        "BatchDeletePartitions",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates partitions in a table.
        pub async fn batch_update_partitions(
            &mut self,
            request: impl tonic::IntoRequest<super::BatchUpdatePartitionsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::BatchUpdatePartitionsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.biglake.hive.v1beta.HiveMetastoreService/BatchUpdatePartitions",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.biglake.hive.v1beta.HiveMetastoreService",
                        "BatchUpdatePartitions",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Streams list of partitions from a table.
        pub async fn list_partitions(
            &mut self,
            request: impl tonic::IntoRequest<super::ListPartitionsRequest>,
        ) -> std::result::Result<
            tonic::Response<tonic::codec::Streaming<super::ListPartitionsResponse>>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.biglake.hive.v1beta.HiveMetastoreService/ListPartitions",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.biglake.hive.v1beta.HiveMetastoreService",
                        "ListPartitions",
                    ),
                );
            self.inner.server_streaming(req, path, codec).await
        }
    }
}
