google-api-proto 1.575.0

/// A reservation is a mechanism used to guarantee slots to users.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Reservation {
    /// The resource name of the reservation, e.g.,
    /// `projects/*/locations/*/reservations/team1-prod`.
    /// The reservation_id must only contain lower case alphanumeric characters or
    /// dashes. It must start with a letter and must not end with a dash. Its
    /// maximum length is 64 characters.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Minimum slots available to this reservation. A slot is a unit of
    /// computational power in BigQuery, and serves as the unit of parallelism.
    ///
    /// Queries using this reservation might use more slots during runtime if
    /// ignore_idle_slots is set to false.
    ///
    /// If total slot_capacity of the reservation and its siblings
    /// exceeds the total slot_count of all capacity commitments, the request will
    /// fail with `google.rpc.Code.RESOURCE_EXHAUSTED`.
    ///
    ///
    /// NOTE: for reservations in US or EU multi-regions, slot capacity constraints
    /// are checked separately for default and auxiliary regions. See
    /// multi_region_auxiliary flag for more details.
    #[prost(int64, tag = "2")]
    pub slot_capacity: i64,
    /// If false, any query or pipeline job using this reservation will use idle
    /// slots from other reservations within the same admin project. If true, a
    /// query or pipeline job using this reservation will execute with the slot
    /// capacity specified in the slot_capacity field at most.
    #[prost(bool, tag = "4")]
    pub ignore_idle_slots: bool,
    /// The configuration parameters for the auto scaling feature. Note this is an
    /// alpha feature.
    #[prost(message, optional, tag = "7")]
    pub autoscale: ::core::option::Option<reservation::Autoscale>,
    /// Job concurrency target which sets a soft upper bound on the number of jobs
    /// that can run concurrently in this reservation. This is a soft target due to
    /// asynchronous nature of the system and various optimizations for small
    /// queries.
    /// Default value is 0 which means that concurrency target will be
    /// automatically computed by the system.
    /// NOTE: this field is exposed as `target_job_concurrency` in the Information
    /// Schema, DDL and BQ CLI.
    #[prost(int64, tag = "16")]
    pub concurrency: i64,
    /// Output only. Creation time of the reservation.
    #[prost(message, optional, tag = "8")]
    pub creation_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Last update time of the reservation.
    #[prost(message, optional, tag = "9")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Applicable only for reservations located within one of the BigQuery
    /// multi-regions (US or EU).
    ///
    /// If set to true, this reservation is placed in the organization's
    /// secondary region which is designated for disaster recovery purposes.
    /// If false, this reservation is placed in the organization's default region.
    ///
    /// NOTE: this is a preview feature. Project must be allow-listed in order to
    /// set this field.
    #[prost(bool, tag = "14")]
    pub multi_region_auxiliary: bool,
    /// Edition of the reservation.
    #[prost(enumeration = "Edition", tag = "17")]
    pub edition: i32,
}
/// Nested message and enum types in `Reservation`.
pub mod reservation {
    /// Auto scaling settings.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Autoscale {
        /// Output only. The slot capacity added to this reservation when autoscale
        /// happens. Will be between \[0, max_slots\].
        #[prost(int64, tag = "1")]
        pub current_slots: i64,
        /// Number of slots to be scaled when needed.
        #[prost(int64, tag = "2")]
        pub max_slots: i64,
    }
}
/// Capacity commitment is a way to purchase compute capacity for BigQuery jobs
/// (in the form of slots) with some committed period of usage. Annual
/// commitments renew by default. Commitments can be removed after their
/// commitment end time passes.
///
/// In order to remove annual commitment, its plan needs to be changed
/// to monthly or flex first.
///
/// A capacity commitment resource exists as a child resource of the admin
/// project.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CapacityCommitment {
    /// Output only. The resource name of the capacity commitment, e.g.,
    /// `projects/myproject/locations/US/capacityCommitments/123`
    /// The commitment_id must only contain lower case alphanumeric characters or
    /// dashes. It must start with a letter and must not end
    /// with a dash. Its maximum length is 64 characters.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Number of slots in this commitment.
    #[prost(int64, tag = "2")]
    pub slot_count: i64,
    /// Capacity commitment commitment plan.
    #[prost(enumeration = "capacity_commitment::CommitmentPlan", tag = "3")]
    pub plan: i32,
    /// Output only. State of the commitment.
    #[prost(enumeration = "capacity_commitment::State", tag = "4")]
    pub state: i32,
    /// Output only. The start of the current commitment period. It is applicable
    /// only for ACTIVE capacity commitments.
    #[prost(message, optional, tag = "9")]
    pub commitment_start_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The end of the current commitment period. It is applicable
    /// only for ACTIVE capacity commitments.
    #[prost(message, optional, tag = "5")]
    pub commitment_end_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. For FAILED commitment plan, provides the reason of failure.
    #[prost(message, optional, tag = "7")]
    pub failure_status: ::core::option::Option<super::super::super::super::rpc::Status>,
    /// The plan this capacity commitment is converted to after commitment_end_time
    /// passes. Once the plan is changed, committed period is extended according to
    /// commitment plan. Only applicable for ANNUAL and TRIAL commitments.
    #[prost(enumeration = "capacity_commitment::CommitmentPlan", tag = "8")]
    pub renewal_plan: i32,
    /// Applicable only for commitments located within one of the BigQuery
    /// multi-regions (US or EU).
    ///
    /// If set to true, this commitment is placed in the organization's
    /// secondary region which is designated for disaster recovery purposes.
    /// If false, this commitment is placed in the organization's default region.
    ///
    /// NOTE: this is a preview feature. Project must be allow-listed in order to
    /// set this field.
    #[prost(bool, tag = "10")]
    pub multi_region_auxiliary: bool,
    /// Edition of the capacity commitment.
    #[prost(enumeration = "Edition", tag = "12")]
    pub edition: i32,
}
/// Nested message and enum types in `CapacityCommitment`.
pub mod capacity_commitment {
    /// Commitment plan defines the current committed period. Capacity commitment
    /// cannot be deleted during it's committed period.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum CommitmentPlan {
        /// Invalid plan value. Requests with this value will be rejected with
        /// error code `google.rpc.Code.INVALID_ARGUMENT`.
        Unspecified = 0,
        /// Flex commitments have committed period of 1 minute after becoming ACTIVE.
        /// After that, they are not in a committed period anymore and can be removed
        /// any time.
        Flex = 3,
        /// Same as FLEX, should only be used if flat-rate commitments are still
        /// available.
        FlexFlatRate = 7,
        /// Trial commitments have a committed period of 182 days after becoming
        /// ACTIVE. After that, they are converted to a new commitment based on the
        /// `renewal_plan`. Default `renewal_plan` for Trial commitment is Flex so
        /// that it can be deleted right after committed period ends.
        Trial = 5,
        /// Monthly commitments have a committed period of 30 days after becoming
        /// ACTIVE. After that, they are not in a committed period anymore and can be
        /// removed any time.
        Monthly = 2,
        /// Same as MONTHLY, should only be used if flat-rate commitments are still
        /// available.
        MonthlyFlatRate = 8,
        /// Annual commitments have a committed period of 365 days after becoming
        /// ACTIVE. After that they are converted to a new commitment based on the
        /// renewal_plan.
        Annual = 4,
        /// Same as ANNUAL, should only be used if flat-rate commitments are still
        /// available.
        AnnualFlatRate = 9,
        /// 3-year commitments have a committed period of 1095(3 * 365) days after
        /// becoming ACTIVE. After that they are converted to a new commitment based
        /// on the renewal_plan.
        ThreeYear = 10,
        /// Should only be used for `renewal_plan` and is only meaningful if
        /// edition is specified to values other than EDITION_UNSPECIFIED. Otherwise
        /// CreateCapacityCommitmentRequest or UpdateCapacityCommitmentRequest will
        /// be rejected with error code `google.rpc.Code.INVALID_ARGUMENT`. If the
        /// renewal_plan is NONE, capacity commitment will be removed at the end of
        /// its commitment period.
        None = 6,
    }
    impl CommitmentPlan {
        /// 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 {
                CommitmentPlan::Unspecified => "COMMITMENT_PLAN_UNSPECIFIED",
                CommitmentPlan::Flex => "FLEX",
                CommitmentPlan::FlexFlatRate => "FLEX_FLAT_RATE",
                CommitmentPlan::Trial => "TRIAL",
                CommitmentPlan::Monthly => "MONTHLY",
                CommitmentPlan::MonthlyFlatRate => "MONTHLY_FLAT_RATE",
                CommitmentPlan::Annual => "ANNUAL",
                CommitmentPlan::AnnualFlatRate => "ANNUAL_FLAT_RATE",
                CommitmentPlan::ThreeYear => "THREE_YEAR",
                CommitmentPlan::None => "NONE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "COMMITMENT_PLAN_UNSPECIFIED" => Some(Self::Unspecified),
                "FLEX" => Some(Self::Flex),
                "FLEX_FLAT_RATE" => Some(Self::FlexFlatRate),
                "TRIAL" => Some(Self::Trial),
                "MONTHLY" => Some(Self::Monthly),
                "MONTHLY_FLAT_RATE" => Some(Self::MonthlyFlatRate),
                "ANNUAL" => Some(Self::Annual),
                "ANNUAL_FLAT_RATE" => Some(Self::AnnualFlatRate),
                "THREE_YEAR" => Some(Self::ThreeYear),
                "NONE" => Some(Self::None),
                _ => None,
            }
        }
    }
    /// Capacity commitment can either become ACTIVE right away or transition
    /// from PENDING to ACTIVE or FAILED.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        /// Invalid state value.
        Unspecified = 0,
        /// Capacity commitment is pending provisioning. Pending capacity commitment
        /// does not contribute to the project's slot_capacity.
        Pending = 1,
        /// Once slots are provisioned, capacity commitment becomes active.
        /// slot_count is added to the project's slot_capacity.
        Active = 2,
        /// Capacity commitment is failed to be activated by the backend.
        Failed = 3,
    }
    impl State {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                State::Unspecified => "STATE_UNSPECIFIED",
                State::Pending => "PENDING",
                State::Active => "ACTIVE",
                State::Failed => "FAILED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATE_UNSPECIFIED" => Some(Self::Unspecified),
                "PENDING" => Some(Self::Pending),
                "ACTIVE" => Some(Self::Active),
                "FAILED" => Some(Self::Failed),
                _ => None,
            }
        }
    }
}
/// The request for
/// [ReservationService.CreateReservation][google.cloud.bigquery.reservation.v1.ReservationService.CreateReservation].
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateReservationRequest {
    /// Required. Project, location. E.g.,
    /// `projects/myproject/locations/US`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The reservation ID. It must only contain lower case alphanumeric
    /// characters or dashes. It must start with a letter and must not end
    /// with a dash. Its maximum length is 64 characters.
    #[prost(string, tag = "2")]
    pub reservation_id: ::prost::alloc::string::String,
    /// Definition of the new reservation to create.
    #[prost(message, optional, tag = "3")]
    pub reservation: ::core::option::Option<Reservation>,
}
/// The request for
/// [ReservationService.ListReservations][google.cloud.bigquery.reservation.v1.ReservationService.ListReservations].
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListReservationsRequest {
    /// Required. The parent resource name containing project and location, e.g.:
    ///    `projects/myproject/locations/US`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The maximum number of items to return per page.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// The next_page_token value returned from a previous List request, if any.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// The response for
/// [ReservationService.ListReservations][google.cloud.bigquery.reservation.v1.ReservationService.ListReservations].
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListReservationsResponse {
    /// List of reservations visible to the user.
    #[prost(message, repeated, tag = "1")]
    pub reservations: ::prost::alloc::vec::Vec<Reservation>,
    /// Token to retrieve the next page of results, or empty if there are no
    /// more results in the list.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// The request for
/// [ReservationService.GetReservation][google.cloud.bigquery.reservation.v1.ReservationService.GetReservation].
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetReservationRequest {
    /// Required. Resource name of the reservation to retrieve. E.g.,
    ///     `projects/myproject/locations/US/reservations/team1-prod`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request for
/// [ReservationService.DeleteReservation][google.cloud.bigquery.reservation.v1.ReservationService.DeleteReservation].
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteReservationRequest {
    /// Required. Resource name of the reservation to retrieve. E.g.,
    ///     `projects/myproject/locations/US/reservations/team1-prod`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request for
/// [ReservationService.UpdateReservation][google.cloud.bigquery.reservation.v1.ReservationService.UpdateReservation].
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateReservationRequest {
    /// Content of the reservation to update.
    #[prost(message, optional, tag = "1")]
    pub reservation: ::core::option::Option<Reservation>,
    /// Standard field mask for the set of fields to be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// The request for
/// [ReservationService.CreateCapacityCommitment][google.cloud.bigquery.reservation.v1.ReservationService.CreateCapacityCommitment].
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateCapacityCommitmentRequest {
    /// Required. Resource name of the parent reservation. E.g.,
    ///     `projects/myproject/locations/US`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Content of the capacity commitment to create.
    #[prost(message, optional, tag = "2")]
    pub capacity_commitment: ::core::option::Option<CapacityCommitment>,
    /// If true, fail the request if another project in the organization has a
    /// capacity commitment.
    #[prost(bool, tag = "4")]
    pub enforce_single_admin_project_per_org: bool,
    /// The optional capacity commitment ID. Capacity commitment name will be
    /// generated automatically if this field is empty.
    /// This field must only contain lower case alphanumeric characters or dashes.
    /// The first and last character cannot be a dash. Max length is 64 characters.
    /// NOTE: this ID won't be kept if the capacity commitment is split or merged.
    #[prost(string, tag = "5")]
    pub capacity_commitment_id: ::prost::alloc::string::String,
}
/// The request for
/// [ReservationService.ListCapacityCommitments][google.cloud.bigquery.reservation.v1.ReservationService.ListCapacityCommitments].
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListCapacityCommitmentsRequest {
    /// Required. Resource name of the parent reservation. E.g.,
    ///     `projects/myproject/locations/US`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The maximum number of items to return.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// The next_page_token value returned from a previous List request, if any.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// The response for
/// [ReservationService.ListCapacityCommitments][google.cloud.bigquery.reservation.v1.ReservationService.ListCapacityCommitments].
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListCapacityCommitmentsResponse {
    /// List of capacity commitments visible to the user.
    #[prost(message, repeated, tag = "1")]
    pub capacity_commitments: ::prost::alloc::vec::Vec<CapacityCommitment>,
    /// Token to retrieve the next page of results, or empty if there are no
    /// more results in the list.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// The request for
/// [ReservationService.GetCapacityCommitment][google.cloud.bigquery.reservation.v1.ReservationService.GetCapacityCommitment].
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetCapacityCommitmentRequest {
    /// Required. Resource name of the capacity commitment to retrieve. E.g.,
    ///     `projects/myproject/locations/US/capacityCommitments/123`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request for
/// [ReservationService.DeleteCapacityCommitment][google.cloud.bigquery.reservation.v1.ReservationService.DeleteCapacityCommitment].
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteCapacityCommitmentRequest {
    /// Required. Resource name of the capacity commitment to delete. E.g.,
    ///     `projects/myproject/locations/US/capacityCommitments/123`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Can be used to force delete commitments even if assignments exist. Deleting
    /// commitments with assignments may cause queries to fail if they no longer
    /// have access to slots.
    #[prost(bool, tag = "3")]
    pub force: bool,
}
/// The request for
/// [ReservationService.UpdateCapacityCommitment][google.cloud.bigquery.reservation.v1.ReservationService.UpdateCapacityCommitment].
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateCapacityCommitmentRequest {
    /// Content of the capacity commitment to update.
    #[prost(message, optional, tag = "1")]
    pub capacity_commitment: ::core::option::Option<CapacityCommitment>,
    /// Standard field mask for the set of fields to be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// The request for
/// [ReservationService.SplitCapacityCommitment][google.cloud.bigquery.reservation.v1.ReservationService.SplitCapacityCommitment].
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SplitCapacityCommitmentRequest {
    /// Required. The resource name e.g.,:
    ///   `projects/myproject/locations/US/capacityCommitments/123`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Number of slots in the capacity commitment after the split.
    #[prost(int64, tag = "2")]
    pub slot_count: i64,
}
/// The response for
/// [ReservationService.SplitCapacityCommitment][google.cloud.bigquery.reservation.v1.ReservationService.SplitCapacityCommitment].
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SplitCapacityCommitmentResponse {
    /// First capacity commitment, result of a split.
    #[prost(message, optional, tag = "1")]
    pub first: ::core::option::Option<CapacityCommitment>,
    /// Second capacity commitment, result of a split.
    #[prost(message, optional, tag = "2")]
    pub second: ::core::option::Option<CapacityCommitment>,
}
/// The request for
/// [ReservationService.MergeCapacityCommitments][google.cloud.bigquery.reservation.v1.ReservationService.MergeCapacityCommitments].
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MergeCapacityCommitmentsRequest {
    /// Parent resource that identifies admin project and location e.g.,
    ///   `projects/myproject/locations/us`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Ids of capacity commitments to merge.
    /// These capacity commitments must exist under admin project and location
    /// specified in the parent.
    /// ID is the last portion of capacity commitment name e.g., 'abc' for
    /// projects/myproject/locations/US/capacityCommitments/abc
    #[prost(string, repeated, tag = "2")]
    pub capacity_commitment_ids: ::prost::alloc::vec::Vec<
        ::prost::alloc::string::String,
    >,
}
/// An assignment allows a project to submit jobs
/// of a certain type using slots from the specified reservation.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Assignment {
    /// Output only. Name of the resource. E.g.:
    /// `projects/myproject/locations/US/reservations/team1-prod/assignments/123`.
    /// The assignment_id must only contain lower case alphanumeric characters or
    /// dashes and the max length is 64 characters.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The resource which will use the reservation. E.g.
    /// `projects/myproject`, `folders/123`, or `organizations/456`.
    #[prost(string, tag = "4")]
    pub assignee: ::prost::alloc::string::String,
    /// Which type of jobs will use the reservation.
    #[prost(enumeration = "assignment::JobType", tag = "3")]
    pub job_type: i32,
    /// Output only. State of the assignment.
    #[prost(enumeration = "assignment::State", tag = "6")]
    pub state: i32,
}
/// Nested message and enum types in `Assignment`.
pub mod assignment {
    /// Types of job, which could be specified when using the reservation.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum JobType {
        /// Invalid type. Requests with this value will be rejected with
        /// error code `google.rpc.Code.INVALID_ARGUMENT`.
        Unspecified = 0,
        /// Pipeline (load/export) jobs from the project will use the reservation.
        Pipeline = 1,
        /// Query jobs from the project will use the reservation.
        Query = 2,
        /// BigQuery ML jobs that use services external to BigQuery for model
        /// training. These jobs will not utilize idle slots from other reservations.
        MlExternal = 3,
        /// Background jobs that BigQuery runs for the customers in the background.
        Background = 4,
    }
    impl JobType {
        /// 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 {
                JobType::Unspecified => "JOB_TYPE_UNSPECIFIED",
                JobType::Pipeline => "PIPELINE",
                JobType::Query => "QUERY",
                JobType::MlExternal => "ML_EXTERNAL",
                JobType::Background => "BACKGROUND",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "JOB_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "PIPELINE" => Some(Self::Pipeline),
                "QUERY" => Some(Self::Query),
                "ML_EXTERNAL" => Some(Self::MlExternal),
                "BACKGROUND" => Some(Self::Background),
                _ => None,
            }
        }
    }
    /// Assignment will remain in PENDING state if no active capacity commitment is
    /// present. It will become ACTIVE when some capacity commitment becomes
    /// active.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        /// Invalid state value.
        Unspecified = 0,
        /// Queries from assignee will be executed as on-demand, if related
        /// assignment is pending.
        Pending = 1,
        /// Assignment is ready.
        Active = 2,
    }
    impl State {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                State::Unspecified => "STATE_UNSPECIFIED",
                State::Pending => "PENDING",
                State::Active => "ACTIVE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATE_UNSPECIFIED" => Some(Self::Unspecified),
                "PENDING" => Some(Self::Pending),
                "ACTIVE" => Some(Self::Active),
                _ => None,
            }
        }
    }
}
/// The request for
/// [ReservationService.CreateAssignment][google.cloud.bigquery.reservation.v1.ReservationService.CreateAssignment].
/// Note: "bigquery.reservationAssignments.create" permission is required on the
/// related assignee.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateAssignmentRequest {
    /// Required. The parent resource name of the assignment
    /// E.g. `projects/myproject/locations/US/reservations/team1-prod`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Assignment resource to create.
    #[prost(message, optional, tag = "2")]
    pub assignment: ::core::option::Option<Assignment>,
    /// The optional assignment ID. Assignment name will be generated automatically
    /// if this field is empty.
    /// This field must only contain lower case alphanumeric characters or dashes.
    /// Max length is 64 characters.
    #[prost(string, tag = "4")]
    pub assignment_id: ::prost::alloc::string::String,
}
/// The request for
/// [ReservationService.ListAssignments][google.cloud.bigquery.reservation.v1.ReservationService.ListAssignments].
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListAssignmentsRequest {
    /// Required. The parent resource name e.g.:
    ///
    /// `projects/myproject/locations/US/reservations/team1-prod`
    ///
    /// Or:
    ///
    /// `projects/myproject/locations/US/reservations/-`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The maximum number of items to return per page.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// The next_page_token value returned from a previous List request, if any.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// The response for
/// [ReservationService.ListAssignments][google.cloud.bigquery.reservation.v1.ReservationService.ListAssignments].
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListAssignmentsResponse {
    /// List of assignments visible to the user.
    #[prost(message, repeated, tag = "1")]
    pub assignments: ::prost::alloc::vec::Vec<Assignment>,
    /// Token to retrieve the next page of results, or empty if there are no
    /// more results in the list.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// The request for
/// [ReservationService.DeleteAssignment][google.cloud.bigquery.reservation.v1.ReservationService.DeleteAssignment].
/// Note: "bigquery.reservationAssignments.delete" permission is required on the
/// related assignee.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteAssignmentRequest {
    /// Required. Name of the resource, e.g.
    ///    `projects/myproject/locations/US/reservations/team1-prod/assignments/123`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request for
/// [ReservationService.SearchAssignments][google.cloud.bigquery.reservation.v1.ReservationService.SearchAssignments].
/// Note: "bigquery.reservationAssignments.search" permission is required on the
/// related assignee.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SearchAssignmentsRequest {
    /// Required. The resource name of the admin project(containing project and
    /// location), e.g.:
    ///    `projects/myproject/locations/US`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Please specify resource name as assignee in the query.
    ///
    /// Examples:
    ///
    /// * `assignee=projects/myproject`
    /// * `assignee=folders/123`
    /// * `assignee=organizations/456`
    #[prost(string, tag = "2")]
    pub query: ::prost::alloc::string::String,
    /// The maximum number of items to return per page.
    #[prost(int32, tag = "3")]
    pub page_size: i32,
    /// The next_page_token value returned from a previous List request, if any.
    #[prost(string, tag = "4")]
    pub page_token: ::prost::alloc::string::String,
}
/// The request for
/// [ReservationService.SearchAllAssignments][google.cloud.bigquery.reservation.v1.ReservationService.SearchAllAssignments].
/// Note: "bigquery.reservationAssignments.search" permission is required on the
/// related assignee.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SearchAllAssignmentsRequest {
    /// Required. The resource name with location (project name could be the
    /// wildcard '-'), e.g.:
    ///    `projects/-/locations/US`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Please specify resource name as assignee in the query.
    ///
    /// Examples:
    ///
    /// * `assignee=projects/myproject`
    /// * `assignee=folders/123`
    /// * `assignee=organizations/456`
    #[prost(string, tag = "2")]
    pub query: ::prost::alloc::string::String,
    /// The maximum number of items to return per page.
    #[prost(int32, tag = "3")]
    pub page_size: i32,
    /// The next_page_token value returned from a previous List request, if any.
    #[prost(string, tag = "4")]
    pub page_token: ::prost::alloc::string::String,
}
/// The response for
/// [ReservationService.SearchAssignments][google.cloud.bigquery.reservation.v1.ReservationService.SearchAssignments].
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SearchAssignmentsResponse {
    /// List of assignments visible to the user.
    #[prost(message, repeated, tag = "1")]
    pub assignments: ::prost::alloc::vec::Vec<Assignment>,
    /// Token to retrieve the next page of results, or empty if there are no
    /// more results in the list.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// The response for
/// [ReservationService.SearchAllAssignments][google.cloud.bigquery.reservation.v1.ReservationService.SearchAllAssignments].
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SearchAllAssignmentsResponse {
    /// List of assignments visible to the user.
    #[prost(message, repeated, tag = "1")]
    pub assignments: ::prost::alloc::vec::Vec<Assignment>,
    /// Token to retrieve the next page of results, or empty if there are no
    /// more results in the list.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// The request for
/// [ReservationService.MoveAssignment][google.cloud.bigquery.reservation.v1.ReservationService.MoveAssignment].
///
/// **Note**: "bigquery.reservationAssignments.create" permission is required on
/// the destination_id.
///
/// **Note**: "bigquery.reservationAssignments.create" and
/// "bigquery.reservationAssignments.delete" permission are required on the
/// related assignee.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MoveAssignmentRequest {
    /// Required. The resource name of the assignment,
    /// e.g.
    /// `projects/myproject/locations/US/reservations/team1-prod/assignments/123`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The new reservation ID, e.g.:
    ///    `projects/myotherproject/locations/US/reservations/team2-prod`
    #[prost(string, tag = "3")]
    pub destination_id: ::prost::alloc::string::String,
    /// The optional assignment ID. A new assignment name is generated if this
    /// field is empty.
    ///
    /// This field can contain only lowercase alphanumeric characters or dashes.
    /// Max length is 64 characters.
    #[prost(string, tag = "5")]
    pub assignment_id: ::prost::alloc::string::String,
}
/// The request for
/// [ReservationService.UpdateAssignment][google.cloud.bigquery.reservation.v1.ReservationService.UpdateAssignment].
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateAssignmentRequest {
    /// Content of the assignment to update.
    #[prost(message, optional, tag = "1")]
    pub assignment: ::core::option::Option<Assignment>,
    /// Standard field mask for the set of fields to be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Fully qualified reference to BigQuery table.
/// Internally stored as google.cloud.bi.v1.BqTableReference.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TableReference {
    /// The assigned project ID of the project.
    #[prost(string, tag = "1")]
    pub project_id: ::prost::alloc::string::String,
    /// The ID of the dataset in the above project.
    #[prost(string, tag = "2")]
    pub dataset_id: ::prost::alloc::string::String,
    /// The ID of the table in the above dataset.
    #[prost(string, tag = "3")]
    pub table_id: ::prost::alloc::string::String,
}
/// Represents a BI Reservation.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BiReservation {
    /// The resource name of the singleton BI reservation.
    /// Reservation names have the form
    /// `projects/{project_id}/locations/{location_id}/biReservation`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. The last update timestamp of a reservation.
    #[prost(message, optional, tag = "3")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Size of a reservation, in bytes.
    #[prost(int64, tag = "4")]
    pub size: i64,
    /// Preferred tables to use BI capacity for.
    #[prost(message, repeated, tag = "5")]
    pub preferred_tables: ::prost::alloc::vec::Vec<TableReference>,
}
/// A request to get a singleton BI reservation.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetBiReservationRequest {
    /// Required. Name of the requested reservation, for example:
    /// `projects/{project_id}/locations/{location_id}/biReservation`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// A request to update a BI reservation.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateBiReservationRequest {
    /// A reservation to update.
    #[prost(message, optional, tag = "1")]
    pub bi_reservation: ::core::option::Option<BiReservation>,
    /// A list of fields to be updated in this request.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// The type of editions.
/// Different features and behaviors are provided to different editions
/// Capacity commitments and reservations are linked to editions.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum Edition {
    /// Default value, which will be treated as ENTERPRISE.
    Unspecified = 0,
    /// Standard edition.
    Standard = 1,
    /// Enterprise edition.
    Enterprise = 2,
    /// Enterprise plus edition.
    EnterprisePlus = 3,
}
impl Edition {
    /// 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 {
            Edition::Unspecified => "EDITION_UNSPECIFIED",
            Edition::Standard => "STANDARD",
            Edition::Enterprise => "ENTERPRISE",
            Edition::EnterprisePlus => "ENTERPRISE_PLUS",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "EDITION_UNSPECIFIED" => Some(Self::Unspecified),
            "STANDARD" => Some(Self::Standard),
            "ENTERPRISE" => Some(Self::Enterprise),
            "ENTERPRISE_PLUS" => Some(Self::EnterprisePlus),
            _ => None,
        }
    }
}
/// Generated client implementations.
pub mod reservation_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// This API allows users to manage their BigQuery reservations.
    ///
    /// A reservation provides computational resource guarantees, in the form of
    /// [slots](https://cloud.google.com/bigquery/docs/slots), to users. A slot is a
    /// unit of computational power in BigQuery, and serves as the basic unit of
    /// parallelism. In a scan of a multi-partitioned table, a single slot operates
    /// on a single partition of the table. A reservation resource exists as a child
    /// resource of the admin project and location, e.g.:
    ///   `projects/myproject/locations/US/reservations/reservationName`.
    ///
    /// A capacity commitment is a way to purchase compute capacity for BigQuery jobs
    /// (in the form of slots) with some committed period of usage. A capacity
    /// commitment resource exists as a child resource of the admin project and
    /// location, e.g.:
    ///   `projects/myproject/locations/US/capacityCommitments/id`.
    #[derive(Debug, Clone)]
    pub struct ReservationServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl<T> ReservationServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + 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,
        ) -> ReservationServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + Send + Sync,
        {
            ReservationServiceClient::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 reservation resource.
        pub async fn create_reservation(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateReservationRequest>,
        ) -> std::result::Result<tonic::Response<super::Reservation>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.bigquery.reservation.v1.ReservationService/CreateReservation",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.bigquery.reservation.v1.ReservationService",
                        "CreateReservation",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists all the reservations for the project in the specified location.
        pub async fn list_reservations(
            &mut self,
            request: impl tonic::IntoRequest<super::ListReservationsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListReservationsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.bigquery.reservation.v1.ReservationService/ListReservations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.bigquery.reservation.v1.ReservationService",
                        "ListReservations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns information about the reservation.
        pub async fn get_reservation(
            &mut self,
            request: impl tonic::IntoRequest<super::GetReservationRequest>,
        ) -> std::result::Result<tonic::Response<super::Reservation>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.bigquery.reservation.v1.ReservationService/GetReservation",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.bigquery.reservation.v1.ReservationService",
                        "GetReservation",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes a reservation.
        /// Returns `google.rpc.Code.FAILED_PRECONDITION` when reservation has
        /// assignments.
        pub async fn delete_reservation(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteReservationRequest>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.bigquery.reservation.v1.ReservationService/DeleteReservation",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.bigquery.reservation.v1.ReservationService",
                        "DeleteReservation",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates an existing reservation resource.
        pub async fn update_reservation(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateReservationRequest>,
        ) -> std::result::Result<tonic::Response<super::Reservation>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.bigquery.reservation.v1.ReservationService/UpdateReservation",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.bigquery.reservation.v1.ReservationService",
                        "UpdateReservation",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a new capacity commitment resource.
        pub async fn create_capacity_commitment(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateCapacityCommitmentRequest>,
        ) -> std::result::Result<
            tonic::Response<super::CapacityCommitment>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.bigquery.reservation.v1.ReservationService/CreateCapacityCommitment",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.bigquery.reservation.v1.ReservationService",
                        "CreateCapacityCommitment",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists all the capacity commitments for the admin project.
        pub async fn list_capacity_commitments(
            &mut self,
            request: impl tonic::IntoRequest<super::ListCapacityCommitmentsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListCapacityCommitmentsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.bigquery.reservation.v1.ReservationService/ListCapacityCommitments",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.bigquery.reservation.v1.ReservationService",
                        "ListCapacityCommitments",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns information about the capacity commitment.
        pub async fn get_capacity_commitment(
            &mut self,
            request: impl tonic::IntoRequest<super::GetCapacityCommitmentRequest>,
        ) -> std::result::Result<
            tonic::Response<super::CapacityCommitment>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.bigquery.reservation.v1.ReservationService/GetCapacityCommitment",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.bigquery.reservation.v1.ReservationService",
                        "GetCapacityCommitment",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes a capacity commitment. Attempting to delete capacity commitment
        /// before its commitment_end_time will fail with the error code
        /// `google.rpc.Code.FAILED_PRECONDITION`.
        pub async fn delete_capacity_commitment(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteCapacityCommitmentRequest>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.bigquery.reservation.v1.ReservationService/DeleteCapacityCommitment",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.bigquery.reservation.v1.ReservationService",
                        "DeleteCapacityCommitment",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates an existing capacity commitment.
        ///
        /// Only `plan` and `renewal_plan` fields can be updated.
        ///
        /// Plan can only be changed to a plan of a longer commitment period.
        /// Attempting to change to a plan with shorter commitment period will fail
        /// with the error code `google.rpc.Code.FAILED_PRECONDITION`.
        pub async fn update_capacity_commitment(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateCapacityCommitmentRequest>,
        ) -> std::result::Result<
            tonic::Response<super::CapacityCommitment>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.bigquery.reservation.v1.ReservationService/UpdateCapacityCommitment",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.bigquery.reservation.v1.ReservationService",
                        "UpdateCapacityCommitment",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Splits capacity commitment to two commitments of the same plan and
        /// `commitment_end_time`.
        ///
        /// A common use case is to enable downgrading commitments.
        ///
        /// For example, in order to downgrade from 10000 slots to 8000, you might
        /// split a 10000 capacity commitment into commitments of 2000 and 8000. Then,
        /// you delete the first one after the commitment end time passes.
        pub async fn split_capacity_commitment(
            &mut self,
            request: impl tonic::IntoRequest<super::SplitCapacityCommitmentRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SplitCapacityCommitmentResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.bigquery.reservation.v1.ReservationService/SplitCapacityCommitment",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.bigquery.reservation.v1.ReservationService",
                        "SplitCapacityCommitment",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Merges capacity commitments of the same plan into a single commitment.
        ///
        /// The resulting capacity commitment has the greater commitment_end_time
        /// out of the to-be-merged capacity commitments.
        ///
        /// Attempting to merge capacity commitments of different plan will fail
        /// with the error code `google.rpc.Code.FAILED_PRECONDITION`.
        pub async fn merge_capacity_commitments(
            &mut self,
            request: impl tonic::IntoRequest<super::MergeCapacityCommitmentsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::CapacityCommitment>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.bigquery.reservation.v1.ReservationService/MergeCapacityCommitments",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.bigquery.reservation.v1.ReservationService",
                        "MergeCapacityCommitments",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates an assignment object which allows the given project to submit jobs
        /// of a certain type using slots from the specified reservation.
        ///
        /// Currently a
        /// resource (project, folder, organization) can only have one assignment per
        /// each (job_type, location) combination, and that reservation will be used
        /// for all jobs of the matching type.
        ///
        /// Different assignments can be created on different levels of the
        /// projects, folders or organization hierarchy.  During query execution,
        /// the assignment is looked up at the project, folder and organization levels
        /// in that order. The first assignment found is applied to the query.
        ///
        /// When creating assignments, it does not matter if other assignments exist at
        /// higher levels.
        ///
        /// Example:
        ///
        /// * The organization `organizationA` contains two projects, `project1`
        ///   and `project2`.
        /// * Assignments for all three entities (`organizationA`, `project1`, and
        ///   `project2`) could all be created and mapped to the same or different
        ///   reservations.
        ///
        /// "None" assignments represent an absence of the assignment. Projects
        /// assigned to None use on-demand pricing. To create a "None" assignment, use
        /// "none" as a reservation_id in the parent. Example parent:
        /// `projects/myproject/locations/US/reservations/none`.
        ///
        /// Returns `google.rpc.Code.PERMISSION_DENIED` if user does not have
        /// 'bigquery.admin' permissions on the project using the reservation
        /// and the project that owns this reservation.
        ///
        /// Returns `google.rpc.Code.INVALID_ARGUMENT` when location of the assignment
        /// does not match location of the reservation.
        pub async fn create_assignment(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateAssignmentRequest>,
        ) -> std::result::Result<tonic::Response<super::Assignment>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.bigquery.reservation.v1.ReservationService/CreateAssignment",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.bigquery.reservation.v1.ReservationService",
                        "CreateAssignment",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists assignments.
        ///
        /// Only explicitly created assignments will be returned.
        ///
        /// Example:
        ///
        /// * Organization `organizationA` contains two projects, `project1` and
        ///   `project2`.
        /// * Reservation `res1` exists and was created previously.
        /// * CreateAssignment was used previously to define the following
        ///   associations between entities and reservations: `<organizationA, res1>`
        ///   and `<project1, res1>`
        ///
        /// In this example, ListAssignments will just return the above two assignments
        /// for reservation `res1`, and no expansion/merge will happen.
        ///
        /// The wildcard "-" can be used for
        /// reservations in the request. In that case all assignments belongs to the
        /// specified project and location will be listed.
        ///
        /// **Note** "-" cannot be used for projects nor locations.
        pub async fn list_assignments(
            &mut self,
            request: impl tonic::IntoRequest<super::ListAssignmentsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListAssignmentsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.bigquery.reservation.v1.ReservationService/ListAssignments",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.bigquery.reservation.v1.ReservationService",
                        "ListAssignments",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes a assignment. No expansion will happen.
        ///
        /// Example:
        ///
        /// * Organization `organizationA` contains two projects, `project1` and
        ///   `project2`.
        /// * Reservation `res1` exists and was created previously.
        /// * CreateAssignment was used previously to define the following
        ///   associations between entities and reservations: `<organizationA, res1>`
        ///   and `<project1, res1>`
        ///
        /// In this example, deletion of the `<organizationA, res1>` assignment won't
        /// affect the other assignment `<project1, res1>`. After said deletion,
        /// queries from `project1` will still use `res1` while queries from
        /// `project2` will switch to use on-demand mode.
        pub async fn delete_assignment(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteAssignmentRequest>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.bigquery.reservation.v1.ReservationService/DeleteAssignment",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.bigquery.reservation.v1.ReservationService",
                        "DeleteAssignment",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deprecated: Looks up assignments for a specified resource for a particular
        /// region. If the request is about a project:
        ///
        /// 1. Assignments created on the project will be returned if they exist.
        /// 2. Otherwise assignments created on the closest ancestor will be
        ///    returned.
        /// 3. Assignments for different JobTypes will all be returned.
        ///
        /// The same logic applies if the request is about a folder.
        ///
        /// If the request is about an organization, then assignments created on the
        /// organization will be returned (organization doesn't have ancestors).
        ///
        /// Comparing to ListAssignments, there are some behavior
        /// differences:
        ///
        /// 1. permission on the assignee will be verified in this API.
        /// 2. Hierarchy lookup (project->folder->organization) happens in this API.
        /// 3. Parent here is `projects/*/locations/*`, instead of
        ///    `projects/*/locations/*reservations/*`.
        ///
        /// **Note** "-" cannot be used for projects
        /// nor locations.
        pub async fn search_assignments(
            &mut self,
            request: impl tonic::IntoRequest<super::SearchAssignmentsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SearchAssignmentsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.bigquery.reservation.v1.ReservationService/SearchAssignments",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.bigquery.reservation.v1.ReservationService",
                        "SearchAssignments",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Looks up assignments for a specified resource for a particular region.
        /// If the request is about a project:
        ///
        /// 1. Assignments created on the project will be returned if they exist.
        /// 2. Otherwise assignments created on the closest ancestor will be
        ///    returned.
        /// 3. Assignments for different JobTypes will all be returned.
        ///
        /// The same logic applies if the request is about a folder.
        ///
        /// If the request is about an organization, then assignments created on the
        /// organization will be returned (organization doesn't have ancestors).
        ///
        /// Comparing to ListAssignments, there are some behavior
        /// differences:
        ///
        /// 1. permission on the assignee will be verified in this API.
        /// 2. Hierarchy lookup (project->folder->organization) happens in this API.
        /// 3. Parent here is `projects/*/locations/*`, instead of
        ///    `projects/*/locations/*reservations/*`.
        pub async fn search_all_assignments(
            &mut self,
            request: impl tonic::IntoRequest<super::SearchAllAssignmentsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SearchAllAssignmentsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.bigquery.reservation.v1.ReservationService/SearchAllAssignments",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.bigquery.reservation.v1.ReservationService",
                        "SearchAllAssignments",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Moves an assignment under a new reservation.
        ///
        /// This differs from removing an existing assignment and recreating a new one
        /// by providing a transactional change that ensures an assignee always has an
        /// associated reservation.
        pub async fn move_assignment(
            &mut self,
            request: impl tonic::IntoRequest<super::MoveAssignmentRequest>,
        ) -> std::result::Result<tonic::Response<super::Assignment>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.bigquery.reservation.v1.ReservationService/MoveAssignment",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.bigquery.reservation.v1.ReservationService",
                        "MoveAssignment",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates an existing assignment.
        ///
        /// Only the `priority` field can be updated.
        pub async fn update_assignment(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateAssignmentRequest>,
        ) -> std::result::Result<tonic::Response<super::Assignment>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.bigquery.reservation.v1.ReservationService/UpdateAssignment",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.bigquery.reservation.v1.ReservationService",
                        "UpdateAssignment",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves a BI reservation.
        pub async fn get_bi_reservation(
            &mut self,
            request: impl tonic::IntoRequest<super::GetBiReservationRequest>,
        ) -> std::result::Result<tonic::Response<super::BiReservation>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.bigquery.reservation.v1.ReservationService/GetBiReservation",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.bigquery.reservation.v1.ReservationService",
                        "GetBiReservation",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates a BI reservation.
        ///
        /// Only fields specified in the `field_mask` are updated.
        ///
        /// A singleton BI reservation always exists with default size 0.
        /// In order to reserve BI capacity it needs to be updated to an amount
        /// greater than 0. In order to release BI capacity reservation size
        /// must be set to 0.
        pub async fn update_bi_reservation(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateBiReservationRequest>,
        ) -> std::result::Result<tonic::Response<super::BiReservation>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.bigquery.reservation.v1.ReservationService/UpdateBiReservation",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.bigquery.reservation.v1.ReservationService",
                        "UpdateBiReservation",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}