yandex-cloud 2025.4.14

/// Represents a link to an object in other service.
/// This object is being billed in the scope of a billing account.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BillableObject {
    /// ID of the object in other service.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Billable object type. Can be one of the following:
    /// * `cloud`
    #[prost(string, tag = "2")]
    pub r#type: ::prost::alloc::string::String,
}
/// Represents a binding of the BillableObject to a BillingAccount.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BillableObjectBinding {
    /// Timestamp when binding was created.
    #[prost(message, optional, tag = "1")]
    pub effective_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Object that is bound to billing account.
    #[prost(message, optional, tag = "2")]
    pub billable_object: ::core::option::Option<BillableObject>,
}
/// A BillingAccount resource. For more information, see \[BillingAccount\](/docs/billing/concepts/billing-account).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BillingAccount {
    /// ID of the billing account.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Name of the billing account.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Creation timestamp.
    #[prost(message, optional, tag = "3")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// ISO 3166-1 alpha-2 country code of the billing account.
    #[prost(string, tag = "4")]
    pub country_code: ::prost::alloc::string::String,
    /// Currency of the billing account.
    /// Can be one of the following:
    /// * `RUB`
    /// * `USD`
    /// * `KZT`
    #[prost(string, tag = "5")]
    pub currency: ::prost::alloc::string::String,
    /// Represents whether corresponding billable objects can be used or not.
    #[prost(bool, tag = "6")]
    pub active: bool,
    /// Current balance of the billing account.
    #[prost(string, tag = "7")]
    pub balance: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetBillingAccountRequest {
    /// ID of the billing account to return.
    /// To get the billing account ID, use \[BillingAccountService.List\] request.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListBillingAccountsRequest {
    /// The maximum number of results per page to return. If the number of available
    /// results is larger than \[page_size\],
    /// the service returns a \[ListBillingAccountsResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token. To get the next page of results,
    /// set \[page_token\] to the \[ListBillingAccountsResponse.next_page_token\]
    /// returned by a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListBillingAccountsResponse {
    /// List of billing accounts.
    #[prost(message, repeated, tag = "1")]
    pub billing_accounts: ::prost::alloc::vec::Vec<BillingAccount>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListBillingAccountsRequest.page_size\], use
    /// \[next_page_token\] as the value
    /// for the \[ListBillingAccountsRequest.page_token\] query parameter
    /// in the next list request. Each subsequent list request will have its own
    /// \[next_page_token\] to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListBillableObjectBindingsRequest {
    /// ID of the billing account to list associated billable object bindings.
    /// To get the billing account ID, use \[BillingAccountService.List\] request.
    #[prost(string, tag = "1")]
    pub billing_account_id: ::prost::alloc::string::String,
    /// The maximum number of results per page to return. If the number of available
    /// results is larger than \[page_size\],
    /// the service returns a \[ListBillableObjectBindingsResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token. To get the next page of results,
    /// set \[page_token\] to the \[ListBillableObjectBindingsResponse.next_page_token\]
    /// returned by a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListBillableObjectBindingsResponse {
    /// List of billable object bindings.
    #[prost(message, repeated, tag = "1")]
    pub billable_object_bindings: ::prost::alloc::vec::Vec<BillableObjectBinding>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListBillableObjectBindingsRequest.page_size\], use
    /// \[next_page_token\] as the value
    /// for the \[ListBillableObjectBindingsRequest.page_token\] query parameter
    /// in the next list request. Each subsequent list request will have its own
    /// \[next_page_token\] to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BindBillableObjectRequest {
    /// ID of the billing account to bind billable object.
    /// To get the billing account ID, use \[BillingAccountService.List\] request.
    #[prost(string, tag = "1")]
    pub billing_account_id: ::prost::alloc::string::String,
    /// \[yandex.cloud.billing.v1.BillableObject\] to bind with billing account.
    #[prost(message, optional, tag = "2")]
    pub billable_object: ::core::option::Option<BillableObject>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BindBillableObjectMetadata {
    /// ID of the \[yandex.cloud.billing.v1.BillableObject\] that was bound to billing account.
    #[prost(string, tag = "1")]
    pub billable_object_id: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod billing_account_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// A set of methods for managing BillingAccount resources.
    #[derive(Debug, Clone)]
    pub struct BillingAccountServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl BillingAccountServiceClient<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> BillingAccountServiceClient<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,
        ) -> BillingAccountServiceClient<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,
        {
            BillingAccountServiceClient::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
        }
        /// Returns the specified billing account.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetBillingAccountRequest>,
        ) -> std::result::Result<tonic::Response<super::BillingAccount>, 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(
                "/yandex.cloud.billing.v1.BillingAccountService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.billing.v1.BillingAccountService",
                        "Get",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of billing accounts available for current user.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListBillingAccountsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListBillingAccountsResponse>,
            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(
                "/yandex.cloud.billing.v1.BillingAccountService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.billing.v1.BillingAccountService",
                        "List",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of billable object bindings associated with the specified billing account.
        pub async fn list_billable_object_bindings(
            &mut self,
            request: impl tonic::IntoRequest<super::ListBillableObjectBindingsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListBillableObjectBindingsResponse>,
            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(
                "/yandex.cloud.billing.v1.BillingAccountService/ListBillableObjectBindings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.billing.v1.BillingAccountService",
                        "ListBillableObjectBindings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Binds billable object to the specified billing account.
        pub async fn bind_billable_object(
            &mut self,
            request: impl tonic::IntoRequest<super::BindBillableObjectRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.billing.v1.BillingAccountService/BindBillableObject",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.billing.v1.BillingAccountService",
                        "BindBillableObject",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists access bindings for the specified billing account.
        pub async fn list_access_bindings(
            &mut self,
            request: impl tonic::IntoRequest<
                super::super::super::access::ListAccessBindingsRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::super::super::access::ListAccessBindingsResponse>,
            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(
                "/yandex.cloud.billing.v1.BillingAccountService/ListAccessBindings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.billing.v1.BillingAccountService",
                        "ListAccessBindings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates access bindings for the specified billing account.
        pub async fn update_access_bindings(
            &mut self,
            request: impl tonic::IntoRequest<
                super::super::super::access::UpdateAccessBindingsRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.billing.v1.BillingAccountService/UpdateAccessBindings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.billing.v1.BillingAccountService",
                        "UpdateAccessBindings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// A Budget resource. For more information, see \[/docs/billing/concepts/budget\].
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Budget {
    /// ID of the budget.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Name of the budget.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Creation timestamp.
    #[prost(message, optional, tag = "3")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// ID of the billing account that the budget belongs to.
    #[prost(string, tag = "4")]
    pub billing_account_id: ::prost::alloc::string::String,
    /// Status of the budget.
    #[prost(enumeration = "BudgetStatus", tag = "5")]
    pub status: i32,
    /// Specification of the budget.
    #[prost(oneof = "budget::BudgetSpec", tags = "6, 7, 8")]
    pub budget_spec: ::core::option::Option<budget::BudgetSpec>,
}
/// Nested message and enum types in `Budget`.
pub mod budget {
    /// Specification of the budget.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum BudgetSpec {
        /// Cost budget specification.
        #[prost(message, tag = "6")]
        CostBudget(super::CostBudgetSpec),
        /// Expense budget specification.
        #[prost(message, tag = "7")]
        ExpenseBudget(super::ExpenseBudgetSpec),
        /// Balance budget specification.
        #[prost(message, tag = "8")]
        BalanceBudget(super::BalanceBudgetSpec),
    }
}
/// Cost budget specification describes budget that can be used to control cost of cloud resources usage.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CostBudgetSpec {
    /// Max cost threshold of the budget. Amount currency is the same as corresponding \[yandex.cloud.billing.v1.BillingAccount.currency\].
    #[prost(string, tag = "1")]
    pub amount: ::prost::alloc::string::String,
    /// IDs of the \[yandex.cloud.iam.v1.UserAccount\].
    /// Specified users will be be notified if the budget exceeds.
    #[prost(string, repeated, tag = "2")]
    pub notification_user_account_ids: ::prost::alloc::vec::Vec<
        ::prost::alloc::string::String,
    >,
    /// List of the \[ThresholdRule\].
    /// Rules define intermediate cost thresholds of the budget.
    #[prost(message, repeated, tag = "3")]
    pub threshold_rules: ::prost::alloc::vec::Vec<ThresholdRule>,
    /// Filter that can be used for specific resources selection. Only consumption cost of selected resources are used for the budget calculation.
    #[prost(message, optional, tag = "4")]
    pub filter: ::core::option::Option<ConsumptionFilter>,
    /// End date of the budget.
    /// Must be the last day of a month and must be formatted like YYYY-MM-DD.
    #[prost(string, tag = "7")]
    pub end_date: ::prost::alloc::string::String,
    /// Start type of the budget.
    #[prost(oneof = "cost_budget_spec::StartType", tags = "5, 6")]
    pub start_type: ::core::option::Option<cost_budget_spec::StartType>,
}
/// Nested message and enum types in `CostBudgetSpec`.
pub mod cost_budget_spec {
    /// Start type of the budget.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum StartType {
        /// Periodic start type that resets budget after specified period is finished.
        /// First time budget is calculated in the current period, i.e. current month, quarter or year.
        #[prost(enumeration = "super::ResetPeriodType", tag = "5")]
        ResetPeriod(i32),
        /// Custom start date of the budget.
        /// Must be the first day of a month and must be formatted like YYYY-MM-DD.
        #[prost(string, tag = "6")]
        StartDate(::prost::alloc::string::String),
    }
}
/// Expense budget specification describes budget that can be used to control expense of cloud resources usage.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExpenseBudgetSpec {
    /// Max expense threshold of the budget. Amount currency is the same as corresponding \[yandex.cloud.billing.v1.BillingAccount.currency\].
    #[prost(string, tag = "1")]
    pub amount: ::prost::alloc::string::String,
    /// IDs of the \[yandex.cloud.iam.v1.UserAccount\].
    /// Specified users will be be notified if the budget exceeds.
    #[prost(string, repeated, tag = "2")]
    pub notification_user_account_ids: ::prost::alloc::vec::Vec<
        ::prost::alloc::string::String,
    >,
    /// List of the \[ThresholdRule\].
    /// Rules define intermediate expense thresholds of the budget.
    #[prost(message, repeated, tag = "3")]
    pub threshold_rules: ::prost::alloc::vec::Vec<ThresholdRule>,
    /// Filter that can be used for specific resources selection. Only consumption expense of selected resources are used for the budget calculation.
    #[prost(message, optional, tag = "4")]
    pub filter: ::core::option::Option<ConsumptionFilter>,
    /// End date of the budget.
    /// Must be the last day of a month and must be formatted like YYYY-MM-DD.
    #[prost(string, tag = "7")]
    pub end_date: ::prost::alloc::string::String,
    /// Start type of the budget.
    #[prost(oneof = "expense_budget_spec::StartType", tags = "5, 6")]
    pub start_type: ::core::option::Option<expense_budget_spec::StartType>,
}
/// Nested message and enum types in `ExpenseBudgetSpec`.
pub mod expense_budget_spec {
    /// Start type of the budget.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum StartType {
        /// Periodic start type that resets budget after specified period is finished.
        /// First time budget is calculated in the current period, i.e. current month, quarter or year.
        #[prost(enumeration = "super::ResetPeriodType", tag = "5")]
        ResetPeriod(i32),
        /// Custom start date of the budget.
        /// Must be the first day of a month and must be formatted like YYYY-MM-DD.
        #[prost(string, tag = "6")]
        StartDate(::prost::alloc::string::String),
    }
}
/// Balance budget specification describes budget that can be used to control \[yandex.cloud.billing.v1.BillingAccount.balance\].
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BalanceBudgetSpec {
    /// Max balance threshold of the budget. Amount currency is the same as corresponding \[yandex.cloud.billing.v1.BillingAccount.currency\].
    #[prost(string, tag = "1")]
    pub amount: ::prost::alloc::string::String,
    /// IDs of the \[yandex.cloud.iam.v1.UserAccount\].
    /// Specified users will be be notified if the budget exceeds.
    #[prost(string, repeated, tag = "2")]
    pub notification_user_account_ids: ::prost::alloc::vec::Vec<
        ::prost::alloc::string::String,
    >,
    /// List of the \[ThresholdRule\].
    /// Rules define intermediate balance thresholds of the budget.
    #[prost(message, repeated, tag = "3")]
    pub threshold_rules: ::prost::alloc::vec::Vec<ThresholdRule>,
    /// Start_date of the budget.
    /// Must be the first day of a month and must be formatted like YYYY-MM-DD.
    #[prost(string, tag = "4")]
    pub start_date: ::prost::alloc::string::String,
    /// End date of the budget.
    /// Must be the last day of a month and must be formatted like YYYY-MM-DD.
    #[prost(string, tag = "5")]
    pub end_date: ::prost::alloc::string::String,
}
/// Filter that can be used for specific resources selection.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ConsumptionFilter {
    /// IDs of the \[yandex.cloud.billing.v1.Service\].
    /// Only consumption of resources corresponding to the given services is used for the budget calculation.
    /// Empty sequence means no services filters.
    #[prost(string, repeated, tag = "1")]
    pub service_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Cloud and folders consumption filter.
    /// Only consumption within specified clouds and folders is used for the budget calculation.
    /// Empty sequence means no cloud and folders filters.
    #[prost(message, repeated, tag = "2")]
    pub cloud_folders_filters: ::prost::alloc::vec::Vec<CloudFoldersConsumptionFilter>,
}
/// Filter that can be used for specific cloud and its folders selection.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CloudFoldersConsumptionFilter {
    /// ID of the \[yandex.cloud.resourcemanager.v1.Cloud\].
    /// Only consumption within specified cloud is used for the budget calculation.
    #[prost(string, tag = "1")]
    pub cloud_id: ::prost::alloc::string::String,
    /// IDs of the \[yandex.cloud.resourcemanager.v1.Folder\].
    /// Only consumption within specified folders of the given cloud is used for the budget calculation.
    /// Empty sequence means no folders filters and the whole cloud consumption will be used.
    #[prost(string, repeated, tag = "2")]
    pub folder_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Rules that define intermediate cost thresholds of the budget.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ThresholdRule {
    /// Type of the rule.
    #[prost(enumeration = "ThresholdType", tag = "1")]
    pub r#type: i32,
    /// Amount of the rule.
    ///   * Must be less than 100 if type is PERCENT.
    ///   * Must be less than budget's amount if type is AMOUNT.
    #[prost(string, tag = "2")]
    pub amount: ::prost::alloc::string::String,
    /// IDs of the \[yandex.cloud.iam.v1.UserAccount\].
    /// Specified users will be be notified if the threshold exceeds.
    #[prost(string, repeated, tag = "3")]
    pub notification_user_account_ids: ::prost::alloc::vec::Vec<
        ::prost::alloc::string::String,
    >,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum BudgetStatus {
    Unspecified = 0,
    /// The budget is being created.
    Creating = 1,
    /// The budget is active.
    Active = 2,
    /// The budget is finished.
    Finished = 3,
}
impl BudgetStatus {
    /// 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 {
            BudgetStatus::Unspecified => "BUDGET_STATUS_UNSPECIFIED",
            BudgetStatus::Creating => "CREATING",
            BudgetStatus::Active => "ACTIVE",
            BudgetStatus::Finished => "FINISHED",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "BUDGET_STATUS_UNSPECIFIED" => Some(Self::Unspecified),
            "CREATING" => Some(Self::Creating),
            "ACTIVE" => Some(Self::Active),
            "FINISHED" => Some(Self::Finished),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ResetPeriodType {
    Unspecified = 0,
    /// Reset budget every month.
    Monthly = 1,
    /// Reset budget every quarter.
    Quarter = 2,
    /// Reset budget every year.
    Annually = 3,
}
impl ResetPeriodType {
    /// 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 {
            ResetPeriodType::Unspecified => "RESET_PERIOD_TYPE_UNSPECIFIED",
            ResetPeriodType::Monthly => "MONTHLY",
            ResetPeriodType::Quarter => "QUARTER",
            ResetPeriodType::Annually => "ANNUALLY",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "RESET_PERIOD_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
            "MONTHLY" => Some(Self::Monthly),
            "QUARTER" => Some(Self::Quarter),
            "ANNUALLY" => Some(Self::Annually),
            _ => None,
        }
    }
}
/// Define the unit of the \[ThesholdRule.amount\].
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ThresholdType {
    Unspecified = 0,
    /// Percent.
    Percent = 1,
    /// The same as budget amount.
    Amount = 2,
}
impl ThresholdType {
    /// 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 {
            ThresholdType::Unspecified => "THRESHOLD_TYPE_UNSPECIFIED",
            ThresholdType::Percent => "PERCENT",
            ThresholdType::Amount => "AMOUNT",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "THRESHOLD_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
            "PERCENT" => Some(Self::Percent),
            "AMOUNT" => Some(Self::Amount),
            _ => None,
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetBudgetRequest {
    /// ID of the budget to return.
    /// To get the budget ID, use \[BudgetService.List\] request.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListBudgetsRequest {
    /// ID of the billing account to list budgets corresponding to.
    /// To get the billing account ID, use \[BillingAccountService.List\] request.
    #[prost(string, tag = "1")]
    pub billing_account_id: ::prost::alloc::string::String,
    /// The maximum number of results per page to return. If the number of available
    /// results is larger than \[page_size\],
    /// the service returns a \[ListBudgetsResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token. To get the next page of results,
    /// set \[page_token\] to the \[ListBudgetsResponse.next_page_token\]
    /// returned by a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListBudgetsResponse {
    /// List of budgets.
    #[prost(message, repeated, tag = "1")]
    pub budgets: ::prost::alloc::vec::Vec<Budget>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListBudgetsRequest.page_size\], use
    /// \[next_page_token\] as the value
    /// for the \[ListBudgetsRequest.page_token\] query parameter
    /// in the next list request. Each subsequent list request will have its own
    /// \[next_page_token\] to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateBudgetRequest {
    /// ID of the billing account to list budgets corresponding to.
    /// To get the billing account ID, use \[yandex.cloud.billing.v1.BillingAccountService.List\] request.
    #[prost(string, tag = "1")]
    pub billing_account_id: ::prost::alloc::string::String,
    /// Name of the budget.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Specification of the budget.
    #[prost(oneof = "create_budget_request::BudgetSpec", tags = "3, 4, 5")]
    pub budget_spec: ::core::option::Option<create_budget_request::BudgetSpec>,
}
/// Nested message and enum types in `CreateBudgetRequest`.
pub mod create_budget_request {
    /// Specification of the budget.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum BudgetSpec {
        /// Cost budget specification.
        #[prost(message, tag = "3")]
        CostBudgetSpec(super::CostBudgetSpec),
        /// Expense budget specification.
        #[prost(message, tag = "4")]
        ExpenseBudgetSpec(super::ExpenseBudgetSpec),
        /// Balance budget specification.
        #[prost(message, tag = "5")]
        BalanceBudgetSpec(super::BalanceBudgetSpec),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateBudgetMetadata {
    /// ID of the budget.
    #[prost(string, tag = "1")]
    pub budget_id: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod budget_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// A set of methods for managing Budget resources.
    #[derive(Debug, Clone)]
    pub struct BudgetServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl BudgetServiceClient<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> BudgetServiceClient<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,
        ) -> BudgetServiceClient<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,
        {
            BudgetServiceClient::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
        }
        /// Returns the specified budget.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetBudgetRequest>,
        ) -> std::result::Result<tonic::Response<super::Budget>, 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(
                "/yandex.cloud.billing.v1.BudgetService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.billing.v1.BudgetService", "Get"));
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of budgets corresponding to the specified billing account.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListBudgetsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListBudgetsResponse>,
            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(
                "/yandex.cloud.billing.v1.BudgetService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.billing.v1.BudgetService", "List"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a budget for the specified billing account.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateBudgetRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.billing.v1.BudgetService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.billing.v1.BudgetService", "Create"),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// A Customer resource.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Customer {
    /// ID of the customer.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// ID of the \[yandex.cloud.billing.v1.BillingAccount\] assigned to the customer.
    #[prost(string, tag = "2")]
    pub billing_account_id: ::prost::alloc::string::String,
}
/// Person of the customer. Contains legal information.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CustomerPerson {
    /// Optional. Name of the person.
    ///
    /// String length is not limited.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. Long name of the person.
    ///
    /// String length is not limited.
    #[prost(string, tag = "2")]
    pub longname: ::prost::alloc::string::String,
    /// Optional. Phone of the person.
    ///
    /// Must be a valid telephone number or a valid \[phoneword\](<https://en.m.wikipedia.org/wiki/Phoneword>).
    #[prost(string, tag = "3")]
    pub phone: ::prost::alloc::string::String,
    /// Optional. Email of the person.
    ///
    /// Must be a valid [email address](<https://en.wikipedia.org/wiki/Email_address>).
    #[prost(string, tag = "4")]
    pub email: ::prost::alloc::string::String,
    /// Optional. Post code of the person.
    ///
    /// String length is not limited.
    #[prost(string, tag = "5")]
    pub post_code: ::prost::alloc::string::String,
    /// Optional. Post address of the person.
    ///
    /// String length is not limited.
    #[prost(string, tag = "6")]
    pub post_address: ::prost::alloc::string::String,
    /// Optional. Legal address of the person.
    ///
    /// String length is not limited.
    #[prost(string, tag = "7")]
    pub legal_address: ::prost::alloc::string::String,
    /// Optional. Tax identification number of the person.
    ///
    /// String length is not limited.
    #[prost(string, tag = "8")]
    pub tin: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListCustomersRequest {
    /// ID of the reseller.
    #[prost(string, tag = "1")]
    pub reseller_id: ::prost::alloc::string::String,
    /// The maximum number of results per page to return. If the number of available
    /// results is larger than \[page_size\],
    /// the service returns a \[ListCustomersResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    #[prost(int64, tag = "3")]
    pub page_size: i64,
    /// Page token. To get the next page of results,
    /// set \[page_token\] to the \[ListCustomersResponse.next_page_token\]
    /// returned by a previous list request.
    #[prost(string, tag = "4")]
    pub page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListCustomersResponse {
    /// List of customers.
    #[prost(message, repeated, tag = "1")]
    pub customers: ::prost::alloc::vec::Vec<Customer>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListCustomersRequest.page_size\], use
    /// \[next_page_token\] as the value
    /// for the \[ListCustomersRequest.page_token\] query parameter
    /// in the next list request. Each subsequent list request will have its own
    /// \[next_page_token\] to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InviteCustomerRequest {
    /// Billing account ID of the reseller that the customer will be associated with.
    #[prost(string, tag = "1")]
    pub reseller_id: ::prost::alloc::string::String,
    /// Name of the customer.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Customer email to send invitation to.
    #[prost(string, tag = "3")]
    pub invitation_email: ::prost::alloc::string::String,
    /// Person of the customer.
    #[prost(message, optional, tag = "4")]
    pub person: ::core::option::Option<CustomerPerson>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateResellerServedCustomerRequest {
    /// ID of the reseller that customer will be associated with.</br>
    ///
    /// Value must match either one of the three regular expressions:
    /// </br>- `^\[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f\]{12}$`
    /// </br>- `^\[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f\]{32}$`
    /// </br>- `^\[a-z][-a-zA-Z0-9.]{0,48}[a-zA-Z0-9\]$`
    #[prost(string, tag = "1")]
    pub reseller_id: ::prost::alloc::string::String,
    /// Name of the customer.
    ///
    /// String length is not limited.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Person of the customer.
    #[prost(message, optional, tag = "3")]
    pub person: ::core::option::Option<CustomerPerson>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ActivateCustomerRequest {
    /// ID of the customer.
    /// To get the customer ID, use \[CustomerService.List\] request.
    #[prost(string, tag = "1")]
    pub customer_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SuspendCustomerRequest {
    /// ID of the customer.
    /// To get the customer ID, use \[CustomerService.List\] request.
    #[prost(string, tag = "1")]
    pub customer_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CustomerMetadata {
    /// ID of the reseller.
    #[prost(string, tag = "1")]
    pub reseller_id: ::prost::alloc::string::String,
    /// ID of the customer.
    #[prost(string, tag = "2")]
    pub customer_id: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod customer_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// A set of methods for managing Customer resources.
    #[derive(Debug, Clone)]
    pub struct CustomerServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl CustomerServiceClient<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> CustomerServiceClient<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,
        ) -> CustomerServiceClient<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,
        {
            CustomerServiceClient::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
        }
        /// Retrieves the list of customers associated with the specified reseller.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListCustomersRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListCustomersResponse>,
            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(
                "/yandex.cloud.billing.v1.CustomerService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.billing.v1.CustomerService", "List"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Invites customer to the specified reseller.
        pub async fn invite(
            &mut self,
            request: impl tonic::IntoRequest<super::InviteCustomerRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.billing.v1.CustomerService/Invite",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.billing.v1.CustomerService", "Invite"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates new reseller-served customer.
        pub async fn create_reseller_served(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateResellerServedCustomerRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.billing.v1.CustomerService/CreateResellerServed",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.billing.v1.CustomerService",
                        "CreateResellerServed",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Activates specified customer. After customer is activated, he can use resources associated with his billing account.
        pub async fn activate(
            &mut self,
            request: impl tonic::IntoRequest<super::ActivateCustomerRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.billing.v1.CustomerService/Activate",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.billing.v1.CustomerService",
                        "Activate",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Suspend specified customer. After customer is suspended, he can't use resources associated with his billing account.
        pub async fn suspend(
            &mut self,
            request: impl tonic::IntoRequest<super::SuspendCustomerRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.billing.v1.CustomerService/Suspend",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.billing.v1.CustomerService", "Suspend"),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// A Service resource.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Service {
    /// ID of the service.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Name of the service, e.g. `Compute Cloud`, `VPC`.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Description of the service.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetServiceRequest {
    /// ID of the service to return.
    /// To get the service ID, use \[ServiceService.List\] request.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListServicesRequest {
    /// A filter expression that filters resources listed in the response.
    /// The expression must specify:
    /// 1. The field name. Currently you can use filtering only on the \[yandex.cloud.billing.v1.Service.id\] field.
    /// 2. An `=` operator.
    /// 3. The value in double quotes (`"`). Must be 3-63 characters long and match the regular expression `\[a-z][-a-z0-9]{1,61}[a-z0-9\]`.
    #[prost(string, tag = "1")]
    pub filter: ::prost::alloc::string::String,
    /// The maximum number of results per page to return. If the number of available
    /// results is larger than \[page_size\],
    /// the service returns a \[ListServicesResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token. To get the next page of results,
    /// set \[page_token\] to the \[ListServicesResponse.next_page_token\]
    /// returned by a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListServicesResponse {
    /// List of services.
    #[prost(message, repeated, tag = "1")]
    pub services: ::prost::alloc::vec::Vec<Service>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListServicesRequest.page_size\], use
    /// \[next_page_token\] as the value
    /// for the \[ListServicesRequest.page_token\] query parameter
    /// in the next list request. Each subsequent list request will have its own
    /// \[next_page_token\] to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod service_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// A set of methods for managing Service resources.
    #[derive(Debug, Clone)]
    pub struct ServiceServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ServiceServiceClient<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> ServiceServiceClient<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,
        ) -> ServiceServiceClient<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,
        {
            ServiceServiceClient::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
        }
        /// Returns the specified service.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetServiceRequest>,
        ) -> std::result::Result<tonic::Response<super::Service>, 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(
                "/yandex.cloud.billing.v1.ServiceService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.billing.v1.ServiceService", "Get"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of services.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListServicesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListServicesResponse>,
            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(
                "/yandex.cloud.billing.v1.ServiceService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.billing.v1.ServiceService", "List"),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// A Stock keeping unit resource.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Sku {
    /// ID of the SKU.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Name of the SKU.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Description of the sku.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// ID of the service that sku belongs to.
    #[prost(string, tag = "4")]
    pub service_id: ::prost::alloc::string::String,
    /// Pricing unit of the SKU, e.g. `core*hour`, `gbyte*hour`.
    #[prost(string, tag = "5")]
    pub pricing_unit: ::prost::alloc::string::String,
    /// List of pricing versions.
    #[prost(message, repeated, tag = "6")]
    pub pricing_versions: ::prost::alloc::vec::Vec<PricingVersion>,
}
/// Pricing version of the SKU.
/// Defines current and past prices for the sku.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PricingVersion {
    /// Type of the pricing version.
    #[prost(enumeration = "PricingVersionType", tag = "1")]
    pub r#type: i32,
    /// Timestamp pricing version is active since inclusive.
    /// The pricing version is active until next pricing version effective time exclusive.
    #[prost(message, optional, tag = "2")]
    pub effective_time: ::core::option::Option<::prost_types::Timestamp>,
    /// List of pricing expressions.
    #[prost(message, repeated, tag = "3")]
    pub pricing_expressions: ::prost::alloc::vec::Vec<PricingExpression>,
}
/// Pricing expression of the pricing version.
/// Defines price for the sku.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PricingExpression {
    /// List of rates.
    #[prost(message, repeated, tag = "2")]
    pub rates: ::prost::alloc::vec::Vec<Rate>,
}
/// Rate of the pricing expression.
/// Define unit price for pricing quantity interval.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Rate {
    /// Start of the pricing quantity interval. The end of the interval is the start pricing quantity of the next rate.
    #[prost(string, tag = "1")]
    pub start_pricing_quantity: ::prost::alloc::string::String,
    /// Unit price for the pricing quantity interval.
    #[prost(string, tag = "2")]
    pub unit_price: ::prost::alloc::string::String,
    /// Currency of the unit price.
    /// Can be one of the following:
    /// * `RUB`
    /// * `USD`
    /// * `KZT`
    #[prost(string, tag = "3")]
    pub currency: ::prost::alloc::string::String,
}
/// Type of the pricing version.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum PricingVersionType {
    Unspecified = 0,
    /// Regular price.
    StreetPrice = 1,
    /// Price is overridden by a contract. Defined in the scope of a billing account.
    ContractPrice = 2,
}
impl PricingVersionType {
    /// 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 {
            PricingVersionType::Unspecified => "PRICING_VERSION_TYPE_UNSPECIFIED",
            PricingVersionType::StreetPrice => "STREET_PRICE",
            PricingVersionType::ContractPrice => "CONTRACT_PRICE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "PRICING_VERSION_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
            "STREET_PRICE" => Some(Self::StreetPrice),
            "CONTRACT_PRICE" => Some(Self::ContractPrice),
            _ => None,
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetSkuRequest {
    /// ID of the SKU to return.
    /// To get the SKU ID, use \[SkuService.List\] request.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Currency of the SKU.
    /// Can be one of the following:
    /// * `RUB`
    /// * `USD`
    /// * `KZT`
    #[prost(string, tag = "2")]
    pub currency: ::prost::alloc::string::String,
    /// Optional ID of the billing account.
    /// If specified, contract prices for a particular billing account are included in the response.
    /// To get the billing account ID, use \[BillingAccountService.List\] request.
    #[prost(string, tag = "3")]
    pub billing_account_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListSkusRequest {
    /// Currency of the prices.
    /// Can be one of the following:
    /// * `RUB`
    /// * `USD`
    /// * `KZT`
    #[prost(string, tag = "1")]
    pub currency: ::prost::alloc::string::String,
    /// Optional ID of the billing account.
    /// If specified, contract prices for a particular billing account are included in the response.
    /// To get the billing account ID, use \[BillingAccountService.List\] request.
    #[prost(string, tag = "2")]
    pub billing_account_id: ::prost::alloc::string::String,
    /// A filter expression that filters resources listed in the response.
    /// The expression must specify:
    /// 1. The field name. Currently you can use filtering only on the \[yandex.cloud.billing.v1.Sku.id\] and \[yandex.cloud.billing.v1.Sku.service_id\] field.
    /// 2. An `=` operator.
    /// 3. The value in double quotes (`"`). Must be 3-63 characters long and match the regular expression `\[a-z][-a-z0-9]{1,61}[a-z0-9\]`.
    /// E.g. `filter=serviceId="dn28hpu6268356q0j8mk"`.
    #[prost(string, tag = "3")]
    pub filter: ::prost::alloc::string::String,
    /// The maximum number of results per page to return. If the number of available
    /// results is larger than \[page_size\],
    /// the service returns a \[ListSkusResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    #[prost(int64, tag = "4")]
    pub page_size: i64,
    /// Page token. To get the next page of results,
    /// set \[page_token\] to the \[ListSkusResponse.next_page_token\]
    /// returned by a previous list request.
    #[prost(string, tag = "5")]
    pub page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListSkusResponse {
    /// List of skus.
    #[prost(message, repeated, tag = "1")]
    pub skus: ::prost::alloc::vec::Vec<Sku>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListSkusRequest.page_size\], use
    /// \[next_page_token\] as the value
    /// for the \[ListSkusRequest.page_token\] query parameter
    /// in the next list request. Each subsequent list request will have its own
    /// \[next_page_token\] to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod sku_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// A set of methods for managing Sku resources.
    #[derive(Debug, Clone)]
    pub struct SkuServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl SkuServiceClient<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> SkuServiceClient<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,
        ) -> SkuServiceClient<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,
        {
            SkuServiceClient::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
        }
        /// Returns the specified SKU.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetSkuRequest>,
        ) -> std::result::Result<tonic::Response<super::Sku>, 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(
                "/yandex.cloud.billing.v1.SkuService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.billing.v1.SkuService", "Get"));
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of SKUs.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListSkusRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListSkusResponse>,
            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(
                "/yandex.cloud.billing.v1.SkuService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.billing.v1.SkuService", "List"));
            self.inner.unary(req, path, codec).await
        }
    }
}