origincloud_billing/generated/

origincloud.billing.v1beta1.rs

// Code generated by origincloud-sdk-generator. DO NOT EDIT.
// source: origincloud/billing/v1beta1/billing_account.proto
// source: origincloud/billing/v1beta1/cost.proto
// source: origincloud/billing/v1beta1/price_list.proto
// source: origincloud/billing/v1beta1/spend_limit.proto

/// An organization's billing account: who invoices are issued to, and how
/// its projects' usage is paid.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct BillingAccount {
    /// The billing account's resource name.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The billing account's URN, the identifier access policies and the audit
    /// log use.
    #[prost(string, tag = "2")]
    pub urn: ::prost::alloc::string::String,
    /// The name the console and spend-limit alerts show. Not empty. An
    /// organization's default account is called `default` until it is
    /// renamed.
    #[prost(string, tag = "3")]
    pub display_name: ::prost::alloc::string::String,
    /// Whether this is the organization's default billing account: the one
    /// its new projects are linked to. Every organization has exactly one,
    /// and it can't be deleted.
    #[prost(bool, tag = "4")]
    pub default_account: bool,
    /// The postal address invoices are issued to. Required to create an
    /// account; unset only on an organization's default account until its
    /// profile is set.
    #[prost(message, optional, tag = "5")]
    pub billing_address: ::core::option::Option<BillingAddress>,
    /// Where invoices are sent. Required to create an account; empty only on
    /// an organization's default account until its profile is set.
    #[prost(string, tag = "6")]
    pub invoice_email: ::prost::alloc::string::String,
    /// The VAT identification number invoices name; empty for none. Required
    /// for a billing address outside Germany.
    #[prost(string, tag = "7")]
    pub vat_id: ::prost::alloc::string::String,
    /// Who invoices are addressed to. Required to create an account; empty
    /// only on an organization's default account until its profile is set.
    #[prost(string, tag = "8")]
    pub contact_person: ::prost::alloc::string::String,
    /// How the account is paid.
    #[prost(message, optional, tag = "9")]
    pub payment_method: ::core::option::Option<PaymentMethod>,
    /// When the billing account was created.
    #[prost(message, optional, tag = "10")]
    pub create_time: ::core::option::Option<::origincloud_core::protobuf::Timestamp>,
    /// The principal that created the billing account, such as `user:<id>` or
    /// `service_account:<id>`.
    #[prost(string, tag = "11")]
    pub creator: ::prost::alloc::string::String,
}
/// A postal address invoices are issued to. Every field is required.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct BillingAddress {
    /// The street and house number.
    #[prost(string, tag = "1")]
    pub street: ::prost::alloc::string::String,
    /// The city.
    #[prost(string, tag = "2")]
    pub city: ::prost::alloc::string::String,
    /// The postal code.
    #[prost(string, tag = "3")]
    pub postal_code: ::prost::alloc::string::String,
    /// The country, as the ISO 3166-1 alpha-2 code of one of the countries
    /// ListBillingCountries lists, such as `DE`.
    #[prost(string, tag = "4")]
    pub region_code: ::prost::alloc::string::String,
}
/// How a billing account is paid. Only the payment method's kind and the
/// last digits of a card are shown; the payment details themselves stay
/// with the payment provider.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PaymentMethod {
    /// Whether the account can pay for usage.
    #[prost(enumeration = "payment_method::State", tag = "1")]
    pub state: i32,
    /// The verified card's brand, such as `visa`; empty while no payment
    /// method is verified, and for one that isn't a card.
    #[prost(string, tag = "2")]
    pub card_brand: ::prost::alloc::string::String,
    /// The verified card's last four digits; empty while no payment method is
    /// verified, and for one that isn't a card.
    #[prost(string, tag = "3")]
    pub card_last4: ::prost::alloc::string::String,
}
/// Nested message and enum types in `PaymentMethod`.
pub mod payment_method {
    /// Whether the account can pay for usage.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        /// Not set.
        Unspecified = 0,
        /// No verified payment method: the projects linked to the account can't
        /// create billable resources until one is added with
        /// StartPaymentMethodSetup and ConfirmPaymentMethodSetup.
        Missing = 1,
        /// A payment method is verified, and billable resources can be created.
        Verified = 2,
        /// The account is invoiced by arrangement with the platform's operator:
        /// it needs no payment method, and the setup methods are refused.
        NotRequired = 3,
    }
    impl State {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "STATE_UNSPECIFIED",
                Self::Missing => "MISSING",
                Self::Verified => "VERIFIED",
                Self::NotRequired => "NOT_REQUIRED",
            }
        }
        /// 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),
                "MISSING" => Some(Self::Missing),
                "VERIFIED" => Some(Self::Verified),
                "NOT_REQUIRED" => Some(Self::NotRequired),
                _ => None,
            }
        }
    }
}
/// Which billing account pays for a project.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ProjectBillingInfo {
    /// The billing info's resource name, `projects/{project}/billingInfo`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The billing account that pays for the project's usage, one of its
    /// organization's.
    #[prost(string, tag = "3")]
    pub billing_account: ::prost::alloc::string::String,
}
/// A country a billing address may be in.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct BillingCountry {
    /// The country's resource name, `billingCountries/{code}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The ISO 3166-1 alpha-2 code a billing address names it by, such as
    /// `DE`.
    #[prost(string, tag = "2")]
    pub region_code: ::prost::alloc::string::String,
    /// The country's name in English.
    #[prost(string, tag = "3")]
    pub display_name: ::prost::alloc::string::String,
    /// Whether a billing account with an address in this country needs a
    /// `vat_id`. Customers in every country but Germany are invoiced without
    /// VAT, as businesses under the reverse-charge rule, which needs one.
    #[prost(bool, tag = "4")]
    pub vat_id_required: bool,
}
/// The request for GetBillingAccount.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetBillingAccountRequest {
    /// The billing account to return.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request for ListBillingAccounts.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListBillingAccountsRequest {
    /// The organization whose billing accounts to list,
    /// `organizations/{organization}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The most billing accounts to return; the server clamps it, and 0 means
    /// its default.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// A previous response's `next_page_token`, for the page after it.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// The response for ListBillingAccounts.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListBillingAccountsResponse {
    /// The billing accounts on this page.
    #[prost(message, repeated, tag = "1")]
    pub billing_accounts: ::prost::alloc::vec::Vec<BillingAccount>,
    /// The token for the next page; empty on the last one.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// The request for CreateBillingAccount.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreateBillingAccountRequest {
    /// The organization to create the billing account in,
    /// `organizations/{organization}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The billing account to create: its `display_name` and profile.
    #[prost(message, optional, tag = "2")]
    pub billing_account: ::core::option::Option<BillingAccount>,
    /// A UUID; a repeat with the same id returns the billing account the first
    /// request created instead of creating a second one.
    #[prost(string, tag = "3")]
    pub request_id: ::prost::alloc::string::String,
}
/// The request for UpdateBillingAccount.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UpdateBillingAccountRequest {
    /// The billing account, by its name, with the fields to change.
    #[prost(message, optional, tag = "1")]
    pub billing_account: ::core::option::Option<BillingAccount>,
    /// The fields to change: `display_name`, `billing_address`,
    /// `invoice_email`, `vat_id` and `contact_person`. `*` is every one of
    /// them.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::origincloud_core::protobuf::FieldMask>,
}
/// The request for DeleteBillingAccount.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteBillingAccountRequest {
    /// The billing account to delete.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request for StartPaymentMethodSetup.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct StartPaymentMethodSetupRequest {
    /// The billing account to add a payment method to.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The response for StartPaymentMethodSetup.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct StartPaymentMethodSetupResponse {
    /// The payment provider's page to open in a browser, where the payment
    /// details are entered. It returns to the console when done.
    #[prost(string, tag = "1")]
    pub redirect_uri: ::prost::alloc::string::String,
}
/// The request for ConfirmPaymentMethodSetup.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ConfirmPaymentMethodSetupRequest {
    /// The billing account whose setup to complete.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request for GetProjectBillingInfo.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetProjectBillingInfoRequest {
    /// The billing info to return, `projects/{project}/billingInfo`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request for UpdateProjectBillingInfo.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UpdateProjectBillingInfoRequest {
    /// The billing info, by its name, with the billing account to link.
    #[prost(message, optional, tag = "1")]
    pub project_billing_info: ::core::option::Option<ProjectBillingInfo>,
    /// The fields to change: `billing_account`. `*` is the same.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::origincloud_core::protobuf::FieldMask>,
}
/// The request for ListProjectBillingInfo.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListProjectBillingInfoRequest {
    /// The billing account whose projects to list.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The most projects to return; the server clamps it, and 0 means its
    /// default.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// A previous response's `next_page_token`, for the page after it.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// The response for ListProjectBillingInfo.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListProjectBillingInfoResponse {
    /// The billing info of each project on this page.
    #[prost(message, repeated, tag = "1")]
    pub project_billing_infos: ::prost::alloc::vec::Vec<ProjectBillingInfo>,
    /// The token for the next page; empty on the last one.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// The request for GetBillingCountry.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetBillingCountryRequest {
    /// The country to return, `billingCountries/{code}`, such as
    /// `billingCountries/DE`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request for ListBillingCountries.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListBillingCountriesRequest {
    /// The most countries to return; the server clamps it, and 0 means its
    /// default.
    #[prost(int32, tag = "1")]
    pub page_size: i32,
    /// A previous response's `next_page_token`, for the page after it.
    #[prost(string, tag = "2")]
    pub page_token: ::prost::alloc::string::String,
}
/// The response for ListBillingCountries.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListBillingCountriesResponse {
    /// The countries on this page.
    #[prost(message, repeated, tag = "1")]
    pub billing_countries: ::prost::alloc::vec::Vec<BillingCountry>,
    /// The token for the next page; empty on the last one.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// A cost report: the period's total, by service and, within a service, by
/// product. Every amount is in EUR, before VAT, as a decimal string.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CostReport {
    /// The period's total.
    #[prost(string, tag = "1")]
    pub total: ::prost::alloc::string::String,
    /// Each service with any cost in the period, such as `compute`, in name
    /// order.
    #[prost(message, repeated, tag = "2")]
    pub services: ::prost::alloc::vec::Vec<ServiceCost>,
}
/// One service's cost in a report.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ServiceCost {
    /// The service, the first segment of its products' keys, such as
    /// `compute`.
    #[prost(string, tag = "1")]
    pub service: ::prost::alloc::string::String,
    /// The service's total.
    #[prost(string, tag = "2")]
    pub total: ::prost::alloc::string::String,
    /// Each of the service's products with any cost in the period, in key
    /// order.
    #[prost(message, repeated, tag = "3")]
    pub products: ::prost::alloc::vec::Vec<ProductCost>,
}
/// One product's cost in a report.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ProductCost {
    /// The product as the price list names it, such as `compute.gp1.core.2`.
    #[prost(string, tag = "1")]
    pub product_key: ::prost::alloc::string::String,
    /// The product's total.
    #[prost(string, tag = "2")]
    pub total: ::prost::alloc::string::String,
    /// The buckets with any cost, oldest first.
    #[prost(message, repeated, tag = "3")]
    pub buckets: ::prost::alloc::vec::Vec<CostBucket>,
}
/// The cost of one hour or one day.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CostBucket {
    /// When the bucket starts.
    #[prost(message, optional, tag = "1")]
    pub start_time: ::core::option::Option<::origincloud_core::protobuf::Timestamp>,
    /// The bucket's cost.
    #[prost(string, tag = "2")]
    pub amount: ::prost::alloc::string::String,
}
/// An organization's cost report: its projects' together, and each
/// project's.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OrganizationCostReport {
    /// The period's total of every project.
    #[prost(string, tag = "1")]
    pub total: ::prost::alloc::string::String,
    /// Each service with any cost in the period, over every project.
    #[prost(message, repeated, tag = "2")]
    pub services: ::prost::alloc::vec::Vec<ServiceCost>,
    /// Each project with any cost in the period, in id order, a project
    /// deleted since included.
    #[prost(message, repeated, tag = "3")]
    pub projects: ::prost::alloc::vec::Vec<ProjectCost>,
}
/// One project's cost in an organization's report, over every service.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ProjectCost {
    /// The project, `projects/{project}`.
    #[prost(string, tag = "1")]
    pub project: ::prost::alloc::string::String,
    /// The project's total.
    #[prost(string, tag = "2")]
    pub total: ::prost::alloc::string::String,
    /// The buckets with any cost, oldest first.
    #[prost(message, repeated, tag = "3")]
    pub buckets: ::prost::alloc::vec::Vec<CostBucket>,
}
/// One metered interval of one resource: how much of a metric it used from
/// `start_time` to `end_time`.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UsageRecord {
    /// The kind of resource, such as `compute.instance`.
    #[prost(string, tag = "1")]
    pub resource_kind: ::prost::alloc::string::String,
    /// The resource's id.
    #[prost(string, tag = "2")]
    pub resource_id: ::prost::alloc::string::String,
    /// What was measured, such as `running_seconds`.
    #[prost(string, tag = "3")]
    pub metric: ::prost::alloc::string::String,
    /// The product the usage is priced as, such as `compute.gp1.core.2`;
    /// empty for a kind of resource that has none.
    #[prost(string, tag = "4")]
    pub product_key: ::prost::alloc::string::String,
    /// How much was used, in the metric's unit, as a decimal string.
    #[prost(string, tag = "5")]
    pub quantity: ::prost::alloc::string::String,
    /// When the interval starts.
    #[prost(message, optional, tag = "6")]
    pub start_time: ::core::option::Option<::origincloud_core::protobuf::Timestamp>,
    /// When the interval ends.
    #[prost(message, optional, tag = "7")]
    pub end_time: ::core::option::Option<::origincloud_core::protobuf::Timestamp>,
    /// The billing account the usage was charged to, the one the project was
    /// linked to when it was recorded; empty if it had none.
    #[prost(string, tag = "8")]
    pub billing_account: ::prost::alloc::string::String,
}
/// The request for QueryProjectCost.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct QueryProjectCostRequest {
    /// The project, `projects/{project}`.
    #[prost(string, tag = "1")]
    pub project: ::prost::alloc::string::String,
    /// The period's start, included.
    #[prost(message, optional, tag = "2")]
    pub start_time: ::core::option::Option<::origincloud_core::protobuf::Timestamp>,
    /// The period's end, left out; after `start_time`.
    #[prost(message, optional, tag = "3")]
    pub end_time: ::core::option::Option<::origincloud_core::protobuf::Timestamp>,
    /// How finely to bucket the cost; daily when unset.
    #[prost(enumeration = "Granularity", tag = "4")]
    pub granularity: i32,
}
/// The request for QueryOrganizationCost.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct QueryOrganizationCostRequest {
    /// The organization, `organizations/{organization}`.
    #[prost(string, tag = "1")]
    pub organization: ::prost::alloc::string::String,
    /// The period's start, included.
    #[prost(message, optional, tag = "2")]
    pub start_time: ::core::option::Option<::origincloud_core::protobuf::Timestamp>,
    /// The period's end, left out; after `start_time`.
    #[prost(message, optional, tag = "3")]
    pub end_time: ::core::option::Option<::origincloud_core::protobuf::Timestamp>,
    /// How finely to bucket the cost; daily when unset.
    #[prost(enumeration = "Granularity", tag = "4")]
    pub granularity: i32,
}
/// The request for QueryBillingAccountCost.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct QueryBillingAccountCostRequest {
    /// The billing account.
    #[prost(string, tag = "1")]
    pub billing_account: ::prost::alloc::string::String,
    /// The period's start, included.
    #[prost(message, optional, tag = "2")]
    pub start_time: ::core::option::Option<::origincloud_core::protobuf::Timestamp>,
    /// The period's end, left out; after `start_time`.
    #[prost(message, optional, tag = "3")]
    pub end_time: ::core::option::Option<::origincloud_core::protobuf::Timestamp>,
    /// How finely to bucket the cost; daily when unset.
    #[prost(enumeration = "Granularity", tag = "4")]
    pub granularity: i32,
}
/// The request for QueryProjectUsage.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct QueryProjectUsageRequest {
    /// The project, `projects/{project}`.
    #[prost(string, tag = "1")]
    pub project: ::prost::alloc::string::String,
    /// The period's start: records that end after it are listed.
    #[prost(message, optional, tag = "2")]
    pub start_time: ::core::option::Option<::origincloud_core::protobuf::Timestamp>,
    /// The period's end: records that start before it are listed; after
    /// `start_time`.
    #[prost(message, optional, tag = "3")]
    pub end_time: ::core::option::Option<::origincloud_core::protobuf::Timestamp>,
    /// The most records to return; the server clamps it, and 0 means its
    /// default.
    #[prost(int32, tag = "4")]
    pub page_size: i32,
    /// A previous response's `next_page_token`, for the page after it.
    #[prost(string, tag = "5")]
    pub page_token: ::prost::alloc::string::String,
}
/// The response for QueryProjectUsage.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryProjectUsageResponse {
    /// The usage records on this page.
    #[prost(message, repeated, tag = "1")]
    pub usage_records: ::prost::alloc::vec::Vec<UsageRecord>,
    /// The token for the next page; empty on the last one.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// How finely a report's cost is bucketed.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum Granularity {
    /// Not set: daily.
    Unspecified = 0,
    /// One bucket per hour, starting on the hour.
    Hourly = 1,
    /// One bucket per day, starting at midnight UTC.
    Daily = 2,
}
impl Granularity {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "GRANULARITY_UNSPECIFIED",
            Self::Hourly => "HOURLY",
            Self::Daily => "DAILY",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "GRANULARITY_UNSPECIFIED" => Some(Self::Unspecified),
            "HOURLY" => Some(Self::Hourly),
            "DAILY" => Some(Self::Daily),
            _ => None,
        }
    }
}
/// The price list. Every amount is in EUR, before VAT, which depends on the
/// customer's country and is added on the invoice.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PriceList {
    /// Always `EUR`.
    #[prost(string, tag = "1")]
    pub currency: ::prost::alloc::string::String,
    /// Always true: every amount is net, before VAT.
    #[prost(bool, tag = "2")]
    pub amounts_exclude_vat: bool,
    /// When a list price was last set, changed, took effect or ended: what a
    /// "prices last updated" line shows. Unset only while nothing is priced.
    #[prost(message, optional, tag = "3")]
    pub last_changed: ::core::option::Option<::origincloud_core::protobuf::Timestamp>,
    /// One entry per product family with a price in effect, in the platform's
    /// catalog order: `compute_instance`, `network_floating_ip`,
    /// `network_nat_gateway`, `network_vpc_egress`, `network_vpc_ingress`,
    /// `network_vpc_internal`, `storage_volume`, `storage_snapshot`,
    /// `observability_custom_metric`, `observability_api_request`,
    /// `observability_ingested_sample`, `dns_hosted_zone`, `dns_query`.
    #[prost(message, repeated, tag = "4")]
    pub families: ::prost::alloc::vec::Vec<PriceFamily>,
}
/// One product family's prices.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PriceFamily {
    /// The family, such as `compute_instance`.
    #[prost(string, tag = "1")]
    pub family: ::prost::alloc::string::String,
    /// The family's prices in effect, by product key, numbers compared as
    /// numbers: a class's instance types run from smallest to largest.
    #[prost(message, repeated, tag = "2")]
    pub prices: ::prost::alloc::vec::Vec<Price>,
}
/// The list price of one product.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Price {
    /// The product the price bills, as usage and cost reports name it, such
    /// as `compute.gp1.core.2`, `storage.gp1` or `network.vpc_egress`.
    #[prost(string, tag = "1")]
    pub product_key: ::prost::alloc::string::String,
    /// The parts of the product key, split out: `instance_type` for an instance,
    /// `storage_class` for a volume. Empty for a product that has none.
    #[prost(btree_map = "string, string", tag = "2")]
    pub dimensions: ::prost::alloc::collections::BTreeMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// What is counted: `seconds`, `gib_hours`, `gb` (decimal, 10^9 bytes),
    /// `metric_months`, `requests`, `samples` or `queries`.
    #[prost(string, tag = "3")]
    pub unit_type: ::prost::alloc::string::String,
    /// How many of the unit the amount pays for: `3600` seconds is an
    /// hourly rate, `1000` requests a rate per thousand.
    #[prost(uint32, tag = "4")]
    pub unit_count: u32,
    /// The price of that many units, as a decimal string.
    #[prost(string, tag = "5")]
    pub amount: ::prost::alloc::string::String,
    /// When the price took effect.
    #[prost(message, optional, tag = "6")]
    pub valid_from: ::core::option::Option<::origincloud_core::protobuf::Timestamp>,
    /// When the price is to end; unset while no end is scheduled.
    #[prost(message, optional, tag = "7")]
    pub valid_until: ::core::option::Option<::origincloud_core::protobuf::Timestamp>,
}
/// The request for GetPriceList, which takes nothing.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetPriceListRequest {}
/// A billing account's spend limit: the most it means to spend in a calendar
/// month, and when to be told. Each threshold alerts once a month, the first
/// time the month's spend crosses it.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SpendLimit {
    /// The spend limit's resource name,
    /// `organizations/{organization}/billingAccounts/{billing_account}/spendLimit`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The amount per calendar month in EUR, before VAT, as a decimal string
    /// such as `500.00`; more than zero. Unset means no spend limit.
    #[prost(string, optional, tag = "2")]
    pub limit: ::core::option::Option<::prost::alloc::string::String>,
    /// The percentages of `limit` whose crossing emails an alert, such as `80`
    /// and `100`; each from 1 to 32767, so a threshold can lie beyond the
    /// limit. Empty while there is no `limit`.
    #[prost(int32, repeated, packed = "false", tag = "3")]
    pub alert_thresholds_percent: ::prost::alloc::vec::Vec<i32>,
    /// Where alerts are sent. Empty while there is no `limit`, and an alert
    /// with no recipient is sent to nobody.
    #[prost(string, repeated, tag = "4")]
    pub notification_emails: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// When the spend limit was last set; unset while there is none.
    #[prost(message, optional, tag = "5")]
    pub update_time: ::core::option::Option<::origincloud_core::protobuf::Timestamp>,
}
/// The request for GetSpendLimit.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetSpendLimitRequest {
    /// The spend limit to return.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request for UpdateSpendLimit.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UpdateSpendLimitRequest {
    /// The spend limit, by its name, with the fields to change.
    #[prost(message, optional, tag = "1")]
    pub spend_limit: ::core::option::Option<SpendLimit>,
    /// The fields to change: `limit`, `alert_thresholds_percent` and
    /// `notification_emails`. `*` is every one of them.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::origincloud_core::protobuf::FieldMask>,
}
impl serde::Serialize for BillingAccount {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.name.is_empty() {
            len += 1;
        }
        if !self.urn.is_empty() {
            len += 1;
        }
        if !self.display_name.is_empty() {
            len += 1;
        }
        if self.default_account {
            len += 1;
        }
        if self.billing_address.is_some() {
            len += 1;
        }
        if !self.invoice_email.is_empty() {
            len += 1;
        }
        if !self.vat_id.is_empty() {
            len += 1;
        }
        if !self.contact_person.is_empty() {
            len += 1;
        }
        if self.payment_method.is_some() {
            len += 1;
        }
        if self.create_time.is_some() {
            len += 1;
        }
        if !self.creator.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.billing.v1beta1.BillingAccount", len)?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        if !self.urn.is_empty() {
            struct_ser.serialize_field("urn", &self.urn)?;
        }
        if !self.display_name.is_empty() {
            struct_ser.serialize_field("displayName", &self.display_name)?;
        }
        if self.default_account {
            struct_ser.serialize_field("defaultAccount", &self.default_account)?;
        }
        if let Some(v) = self.billing_address.as_ref() {
            struct_ser.serialize_field("billingAddress", v)?;
        }
        if !self.invoice_email.is_empty() {
            struct_ser.serialize_field("invoiceEmail", &self.invoice_email)?;
        }
        if !self.vat_id.is_empty() {
            struct_ser.serialize_field("vatId", &self.vat_id)?;
        }
        if !self.contact_person.is_empty() {
            struct_ser.serialize_field("contactPerson", &self.contact_person)?;
        }
        if let Some(v) = self.payment_method.as_ref() {
            struct_ser.serialize_field("paymentMethod", v)?;
        }
        if let Some(v) = self.create_time.as_ref() {
            struct_ser.serialize_field("createTime", v)?;
        }
        if !self.creator.is_empty() {
            struct_ser.serialize_field("creator", &self.creator)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for BillingAccount {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "name",
            "urn",
            "display_name",
            "displayName",
            "default_account",
            "defaultAccount",
            "billing_address",
            "billingAddress",
            "invoice_email",
            "invoiceEmail",
            "vat_id",
            "vatId",
            "contact_person",
            "contactPerson",
            "payment_method",
            "paymentMethod",
            "create_time",
            "createTime",
            "creator",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            Urn,
            DisplayName,
            DefaultAccount,
            BillingAddress,
            InvoiceEmail,
            VatId,
            ContactPerson,
            PaymentMethod,
            CreateTime,
            Creator,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "name" => Ok(GeneratedField::Name),
                            "urn" => Ok(GeneratedField::Urn),
                            "displayName" | "display_name" => {
                                Ok(GeneratedField::DisplayName)
                            }
                            "defaultAccount" | "default_account" => {
                                Ok(GeneratedField::DefaultAccount)
                            }
                            "billingAddress" | "billing_address" => {
                                Ok(GeneratedField::BillingAddress)
                            }
                            "invoiceEmail" | "invoice_email" => {
                                Ok(GeneratedField::InvoiceEmail)
                            }
                            "vatId" | "vat_id" => Ok(GeneratedField::VatId),
                            "contactPerson" | "contact_person" => {
                                Ok(GeneratedField::ContactPerson)
                            }
                            "paymentMethod" | "payment_method" => {
                                Ok(GeneratedField::PaymentMethod)
                            }
                            "createTime" | "create_time" => {
                                Ok(GeneratedField::CreateTime)
                            }
                            "creator" => Ok(GeneratedField::Creator),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = BillingAccount;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.billing.v1beta1.BillingAccount")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<BillingAccount, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                let mut urn__ = None;
                let mut display_name__ = None;
                let mut default_account__ = None;
                let mut billing_address__ = None;
                let mut invoice_email__ = None;
                let mut vat_id__ = None;
                let mut contact_person__ = None;
                let mut payment_method__ = None;
                let mut create_time__ = None;
                let mut creator__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Name => {
                            if name__.is_some() {
                                return Err(serde::de::Error::duplicate_field("name"));
                            }
                            name__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Urn => {
                            if urn__.is_some() {
                                return Err(serde::de::Error::duplicate_field("urn"));
                            }
                            urn__ = Some(map_.next_value()?);
                        }
                        GeneratedField::DisplayName => {
                            if display_name__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("displayName"),
                                );
                            }
                            display_name__ = Some(map_.next_value()?);
                        }
                        GeneratedField::DefaultAccount => {
                            if default_account__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("defaultAccount"),
                                );
                            }
                            default_account__ = Some(map_.next_value()?);
                        }
                        GeneratedField::BillingAddress => {
                            if billing_address__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("billingAddress"),
                                );
                            }
                            billing_address__ = map_.next_value()?;
                        }
                        GeneratedField::InvoiceEmail => {
                            if invoice_email__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("invoiceEmail"),
                                );
                            }
                            invoice_email__ = Some(map_.next_value()?);
                        }
                        GeneratedField::VatId => {
                            if vat_id__.is_some() {
                                return Err(serde::de::Error::duplicate_field("vatId"));
                            }
                            vat_id__ = Some(map_.next_value()?);
                        }
                        GeneratedField::ContactPerson => {
                            if contact_person__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("contactPerson"),
                                );
                            }
                            contact_person__ = Some(map_.next_value()?);
                        }
                        GeneratedField::PaymentMethod => {
                            if payment_method__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("paymentMethod"),
                                );
                            }
                            payment_method__ = map_.next_value()?;
                        }
                        GeneratedField::CreateTime => {
                            if create_time__.is_some() {
                                return Err(serde::de::Error::duplicate_field("createTime"));
                            }
                            create_time__ = map_.next_value()?;
                        }
                        GeneratedField::Creator => {
                            if creator__.is_some() {
                                return Err(serde::de::Error::duplicate_field("creator"));
                            }
                            creator__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(BillingAccount {
                    name: name__.unwrap_or_default(),
                    urn: urn__.unwrap_or_default(),
                    display_name: display_name__.unwrap_or_default(),
                    default_account: default_account__.unwrap_or_default(),
                    billing_address: billing_address__,
                    invoice_email: invoice_email__.unwrap_or_default(),
                    vat_id: vat_id__.unwrap_or_default(),
                    contact_person: contact_person__.unwrap_or_default(),
                    payment_method: payment_method__,
                    create_time: create_time__,
                    creator: creator__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.BillingAccount",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for BillingAddress {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.street.is_empty() {
            len += 1;
        }
        if !self.city.is_empty() {
            len += 1;
        }
        if !self.postal_code.is_empty() {
            len += 1;
        }
        if !self.region_code.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.billing.v1beta1.BillingAddress", len)?;
        if !self.street.is_empty() {
            struct_ser.serialize_field("street", &self.street)?;
        }
        if !self.city.is_empty() {
            struct_ser.serialize_field("city", &self.city)?;
        }
        if !self.postal_code.is_empty() {
            struct_ser.serialize_field("postalCode", &self.postal_code)?;
        }
        if !self.region_code.is_empty() {
            struct_ser.serialize_field("regionCode", &self.region_code)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for BillingAddress {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "street",
            "city",
            "postal_code",
            "postalCode",
            "region_code",
            "regionCode",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Street,
            City,
            PostalCode,
            RegionCode,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "street" => Ok(GeneratedField::Street),
                            "city" => Ok(GeneratedField::City),
                            "postalCode" | "postal_code" => {
                                Ok(GeneratedField::PostalCode)
                            }
                            "regionCode" | "region_code" => {
                                Ok(GeneratedField::RegionCode)
                            }
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = BillingAddress;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.billing.v1beta1.BillingAddress")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<BillingAddress, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut street__ = None;
                let mut city__ = None;
                let mut postal_code__ = None;
                let mut region_code__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Street => {
                            if street__.is_some() {
                                return Err(serde::de::Error::duplicate_field("street"));
                            }
                            street__ = Some(map_.next_value()?);
                        }
                        GeneratedField::City => {
                            if city__.is_some() {
                                return Err(serde::de::Error::duplicate_field("city"));
                            }
                            city__ = Some(map_.next_value()?);
                        }
                        GeneratedField::PostalCode => {
                            if postal_code__.is_some() {
                                return Err(serde::de::Error::duplicate_field("postalCode"));
                            }
                            postal_code__ = Some(map_.next_value()?);
                        }
                        GeneratedField::RegionCode => {
                            if region_code__.is_some() {
                                return Err(serde::de::Error::duplicate_field("regionCode"));
                            }
                            region_code__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(BillingAddress {
                    street: street__.unwrap_or_default(),
                    city: city__.unwrap_or_default(),
                    postal_code: postal_code__.unwrap_or_default(),
                    region_code: region_code__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.BillingAddress",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for BillingCountry {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.name.is_empty() {
            len += 1;
        }
        if !self.region_code.is_empty() {
            len += 1;
        }
        if !self.display_name.is_empty() {
            len += 1;
        }
        if self.vat_id_required {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.billing.v1beta1.BillingCountry", len)?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        if !self.region_code.is_empty() {
            struct_ser.serialize_field("regionCode", &self.region_code)?;
        }
        if !self.display_name.is_empty() {
            struct_ser.serialize_field("displayName", &self.display_name)?;
        }
        if self.vat_id_required {
            struct_ser.serialize_field("vatIdRequired", &self.vat_id_required)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for BillingCountry {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "name",
            "region_code",
            "regionCode",
            "display_name",
            "displayName",
            "vat_id_required",
            "vatIdRequired",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            RegionCode,
            DisplayName,
            VatIdRequired,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "name" => Ok(GeneratedField::Name),
                            "regionCode" | "region_code" => {
                                Ok(GeneratedField::RegionCode)
                            }
                            "displayName" | "display_name" => {
                                Ok(GeneratedField::DisplayName)
                            }
                            "vatIdRequired" | "vat_id_required" => {
                                Ok(GeneratedField::VatIdRequired)
                            }
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = BillingCountry;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.billing.v1beta1.BillingCountry")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<BillingCountry, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                let mut region_code__ = None;
                let mut display_name__ = None;
                let mut vat_id_required__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Name => {
                            if name__.is_some() {
                                return Err(serde::de::Error::duplicate_field("name"));
                            }
                            name__ = Some(map_.next_value()?);
                        }
                        GeneratedField::RegionCode => {
                            if region_code__.is_some() {
                                return Err(serde::de::Error::duplicate_field("regionCode"));
                            }
                            region_code__ = Some(map_.next_value()?);
                        }
                        GeneratedField::DisplayName => {
                            if display_name__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("displayName"),
                                );
                            }
                            display_name__ = Some(map_.next_value()?);
                        }
                        GeneratedField::VatIdRequired => {
                            if vat_id_required__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("vatIdRequired"),
                                );
                            }
                            vat_id_required__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(BillingCountry {
                    name: name__.unwrap_or_default(),
                    region_code: region_code__.unwrap_or_default(),
                    display_name: display_name__.unwrap_or_default(),
                    vat_id_required: vat_id_required__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.BillingCountry",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ConfirmPaymentMethodSetupRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.name.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.billing.v1beta1.ConfirmPaymentMethodSetupRequest",
                len,
            )?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ConfirmPaymentMethodSetupRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["name"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "name" => Ok(GeneratedField::Name),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = ConfirmPaymentMethodSetupRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.billing.v1beta1.ConfirmPaymentMethodSetupRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ConfirmPaymentMethodSetupRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Name => {
                            if name__.is_some() {
                                return Err(serde::de::Error::duplicate_field("name"));
                            }
                            name__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(ConfirmPaymentMethodSetupRequest {
                    name: name__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.ConfirmPaymentMethodSetupRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for CostBucket {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if self.start_time.is_some() {
            len += 1;
        }
        if !self.amount.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.billing.v1beta1.CostBucket", len)?;
        if let Some(v) = self.start_time.as_ref() {
            struct_ser.serialize_field("startTime", v)?;
        }
        if !self.amount.is_empty() {
            struct_ser.serialize_field("amount", &self.amount)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for CostBucket {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["start_time", "startTime", "amount"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            StartTime,
            Amount,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "startTime" | "start_time" => Ok(GeneratedField::StartTime),
                            "amount" => Ok(GeneratedField::Amount),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = CostBucket;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.billing.v1beta1.CostBucket")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<CostBucket, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut start_time__ = None;
                let mut amount__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::StartTime => {
                            if start_time__.is_some() {
                                return Err(serde::de::Error::duplicate_field("startTime"));
                            }
                            start_time__ = map_.next_value()?;
                        }
                        GeneratedField::Amount => {
                            if amount__.is_some() {
                                return Err(serde::de::Error::duplicate_field("amount"));
                            }
                            amount__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(CostBucket {
                    start_time: start_time__,
                    amount: amount__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.CostBucket",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for CostReport {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.total.is_empty() {
            len += 1;
        }
        if !self.services.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.billing.v1beta1.CostReport", len)?;
        if !self.total.is_empty() {
            struct_ser.serialize_field("total", &self.total)?;
        }
        if !self.services.is_empty() {
            struct_ser.serialize_field("services", &self.services)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for CostReport {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["total", "services"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Total,
            Services,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "total" => Ok(GeneratedField::Total),
                            "services" => Ok(GeneratedField::Services),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = CostReport;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.billing.v1beta1.CostReport")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<CostReport, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut total__ = None;
                let mut services__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Total => {
                            if total__.is_some() {
                                return Err(serde::de::Error::duplicate_field("total"));
                            }
                            total__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Services => {
                            if services__.is_some() {
                                return Err(serde::de::Error::duplicate_field("services"));
                            }
                            services__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(CostReport {
                    total: total__.unwrap_or_default(),
                    services: services__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.CostReport",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for CreateBillingAccountRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.parent.is_empty() {
            len += 1;
        }
        if self.billing_account.is_some() {
            len += 1;
        }
        if !self.request_id.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.billing.v1beta1.CreateBillingAccountRequest",
                len,
            )?;
        if !self.parent.is_empty() {
            struct_ser.serialize_field("parent", &self.parent)?;
        }
        if let Some(v) = self.billing_account.as_ref() {
            struct_ser.serialize_field("billingAccount", v)?;
        }
        if !self.request_id.is_empty() {
            struct_ser.serialize_field("requestId", &self.request_id)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for CreateBillingAccountRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "parent",
            "billing_account",
            "billingAccount",
            "request_id",
            "requestId",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Parent,
            BillingAccount,
            RequestId,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "parent" => Ok(GeneratedField::Parent),
                            "billingAccount" | "billing_account" => {
                                Ok(GeneratedField::BillingAccount)
                            }
                            "requestId" | "request_id" => Ok(GeneratedField::RequestId),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = CreateBillingAccountRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.billing.v1beta1.CreateBillingAccountRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<CreateBillingAccountRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut parent__ = None;
                let mut billing_account__ = None;
                let mut request_id__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Parent => {
                            if parent__.is_some() {
                                return Err(serde::de::Error::duplicate_field("parent"));
                            }
                            parent__ = Some(map_.next_value()?);
                        }
                        GeneratedField::BillingAccount => {
                            if billing_account__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("billingAccount"),
                                );
                            }
                            billing_account__ = map_.next_value()?;
                        }
                        GeneratedField::RequestId => {
                            if request_id__.is_some() {
                                return Err(serde::de::Error::duplicate_field("requestId"));
                            }
                            request_id__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(CreateBillingAccountRequest {
                    parent: parent__.unwrap_or_default(),
                    billing_account: billing_account__,
                    request_id: request_id__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.CreateBillingAccountRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for DeleteBillingAccountRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.name.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.billing.v1beta1.DeleteBillingAccountRequest",
                len,
            )?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for DeleteBillingAccountRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["name"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "name" => Ok(GeneratedField::Name),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = DeleteBillingAccountRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.billing.v1beta1.DeleteBillingAccountRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<DeleteBillingAccountRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Name => {
                            if name__.is_some() {
                                return Err(serde::de::Error::duplicate_field("name"));
                            }
                            name__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(DeleteBillingAccountRequest {
                    name: name__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.DeleteBillingAccountRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for GetBillingAccountRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.name.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.billing.v1beta1.GetBillingAccountRequest",
                len,
            )?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for GetBillingAccountRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["name"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "name" => Ok(GeneratedField::Name),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = GetBillingAccountRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.billing.v1beta1.GetBillingAccountRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<GetBillingAccountRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Name => {
                            if name__.is_some() {
                                return Err(serde::de::Error::duplicate_field("name"));
                            }
                            name__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(GetBillingAccountRequest {
                    name: name__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.GetBillingAccountRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for GetBillingCountryRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.name.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.billing.v1beta1.GetBillingCountryRequest",
                len,
            )?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for GetBillingCountryRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["name"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "name" => Ok(GeneratedField::Name),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = GetBillingCountryRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.billing.v1beta1.GetBillingCountryRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<GetBillingCountryRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Name => {
                            if name__.is_some() {
                                return Err(serde::de::Error::duplicate_field("name"));
                            }
                            name__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(GetBillingCountryRequest {
                    name: name__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.GetBillingCountryRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for GetPriceListRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let len = 0;
        let struct_ser = serializer
            .serialize_struct("origincloud.billing.v1beta1.GetPriceListRequest", len)?;
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for GetPriceListRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        Ok(GeneratedField::__SkipField__)
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = GetPriceListRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.billing.v1beta1.GetPriceListRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<GetPriceListRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                while map_.next_key::<GeneratedField>()?.is_some() {
                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                }
                Ok(GetPriceListRequest {})
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.GetPriceListRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for GetProjectBillingInfoRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.name.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.billing.v1beta1.GetProjectBillingInfoRequest",
                len,
            )?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for GetProjectBillingInfoRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["name"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "name" => Ok(GeneratedField::Name),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = GetProjectBillingInfoRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.billing.v1beta1.GetProjectBillingInfoRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<GetProjectBillingInfoRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Name => {
                            if name__.is_some() {
                                return Err(serde::de::Error::duplicate_field("name"));
                            }
                            name__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(GetProjectBillingInfoRequest {
                    name: name__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.GetProjectBillingInfoRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for GetSpendLimitRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.name.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.billing.v1beta1.GetSpendLimitRequest", len)?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for GetSpendLimitRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["name"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "name" => Ok(GeneratedField::Name),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = GetSpendLimitRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.billing.v1beta1.GetSpendLimitRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<GetSpendLimitRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Name => {
                            if name__.is_some() {
                                return Err(serde::de::Error::duplicate_field("name"));
                            }
                            name__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(GetSpendLimitRequest {
                    name: name__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.GetSpendLimitRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for Granularity {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        let variant = match self {
            Self::Unspecified => "GRANULARITY_UNSPECIFIED",
            Self::Hourly => "HOURLY",
            Self::Daily => "DAILY",
        };
        serializer.serialize_str(variant)
    }
}
impl<'de> serde::Deserialize<'de> for Granularity {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["GRANULARITY_UNSPECIFIED", "HOURLY", "DAILY"];
        struct GeneratedVisitor;
        impl serde::de::Visitor<'_> for GeneratedVisitor {
            type Value = Granularity;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                write!(formatter, "expected one of: {:?}", & FIELDS)
            }
            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
            where
                E: serde::de::Error,
            {
                i32::try_from(v)
                    .ok()
                    .and_then(|x| {
                        x.try_into().ok().or_else(|| Some(Granularity::default()))
                    })
                    .ok_or_else(|| {
                        serde::de::Error::invalid_value(
                            serde::de::Unexpected::Signed(v),
                            &self,
                        )
                    })
            }
            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
            where
                E: serde::de::Error,
            {
                i32::try_from(v)
                    .ok()
                    .and_then(|x| {
                        x.try_into().ok().or_else(|| Some(Granularity::default()))
                    })
                    .ok_or_else(|| {
                        serde::de::Error::invalid_value(
                            serde::de::Unexpected::Unsigned(v),
                            &self,
                        )
                    })
            }
            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
            where
                E: serde::de::Error,
            {
                match value {
                    "GRANULARITY_UNSPECIFIED" => Ok(Granularity::Unspecified),
                    "HOURLY" => Ok(Granularity::Hourly),
                    "DAILY" => Ok(Granularity::Daily),
                    _ => Ok(Granularity::default()),
                }
            }
        }
        deserializer.deserialize_any(GeneratedVisitor)
    }
}
impl serde::Serialize for ListBillingAccountsRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.parent.is_empty() {
            len += 1;
        }
        if self.page_size != 0 {
            len += 1;
        }
        if !self.page_token.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.billing.v1beta1.ListBillingAccountsRequest",
                len,
            )?;
        if !self.parent.is_empty() {
            struct_ser.serialize_field("parent", &self.parent)?;
        }
        if self.page_size != 0 {
            struct_ser.serialize_field("pageSize", &self.page_size)?;
        }
        if !self.page_token.is_empty() {
            struct_ser.serialize_field("pageToken", &self.page_token)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ListBillingAccountsRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "parent",
            "page_size",
            "pageSize",
            "page_token",
            "pageToken",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Parent,
            PageSize,
            PageToken,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "parent" => Ok(GeneratedField::Parent),
                            "pageSize" | "page_size" => Ok(GeneratedField::PageSize),
                            "pageToken" | "page_token" => Ok(GeneratedField::PageToken),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = ListBillingAccountsRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.billing.v1beta1.ListBillingAccountsRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListBillingAccountsRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut parent__ = None;
                let mut page_size__ = None;
                let mut page_token__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Parent => {
                            if parent__.is_some() {
                                return Err(serde::de::Error::duplicate_field("parent"));
                            }
                            parent__ = Some(map_.next_value()?);
                        }
                        GeneratedField::PageSize => {
                            if page_size__.is_some() {
                                return Err(serde::de::Error::duplicate_field("pageSize"));
                            }
                            page_size__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::PageToken => {
                            if page_token__.is_some() {
                                return Err(serde::de::Error::duplicate_field("pageToken"));
                            }
                            page_token__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(ListBillingAccountsRequest {
                    parent: parent__.unwrap_or_default(),
                    page_size: page_size__.unwrap_or_default(),
                    page_token: page_token__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.ListBillingAccountsRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListBillingAccountsResponse {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.billing_accounts.is_empty() {
            len += 1;
        }
        if !self.next_page_token.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.billing.v1beta1.ListBillingAccountsResponse",
                len,
            )?;
        if !self.billing_accounts.is_empty() {
            struct_ser.serialize_field("billingAccounts", &self.billing_accounts)?;
        }
        if !self.next_page_token.is_empty() {
            struct_ser.serialize_field("nextPageToken", &self.next_page_token)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ListBillingAccountsResponse {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "billing_accounts",
            "billingAccounts",
            "next_page_token",
            "nextPageToken",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            BillingAccounts,
            NextPageToken,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "billingAccounts" | "billing_accounts" => {
                                Ok(GeneratedField::BillingAccounts)
                            }
                            "nextPageToken" | "next_page_token" => {
                                Ok(GeneratedField::NextPageToken)
                            }
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = ListBillingAccountsResponse;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.billing.v1beta1.ListBillingAccountsResponse",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListBillingAccountsResponse, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut billing_accounts__ = None;
                let mut next_page_token__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::BillingAccounts => {
                            if billing_accounts__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("billingAccounts"),
                                );
                            }
                            billing_accounts__ = Some(map_.next_value()?);
                        }
                        GeneratedField::NextPageToken => {
                            if next_page_token__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("nextPageToken"),
                                );
                            }
                            next_page_token__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(ListBillingAccountsResponse {
                    billing_accounts: billing_accounts__.unwrap_or_default(),
                    next_page_token: next_page_token__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.ListBillingAccountsResponse",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListBillingCountriesRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if self.page_size != 0 {
            len += 1;
        }
        if !self.page_token.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.billing.v1beta1.ListBillingCountriesRequest",
                len,
            )?;
        if self.page_size != 0 {
            struct_ser.serialize_field("pageSize", &self.page_size)?;
        }
        if !self.page_token.is_empty() {
            struct_ser.serialize_field("pageToken", &self.page_token)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ListBillingCountriesRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["page_size", "pageSize", "page_token", "pageToken"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            PageSize,
            PageToken,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "pageSize" | "page_size" => Ok(GeneratedField::PageSize),
                            "pageToken" | "page_token" => Ok(GeneratedField::PageToken),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = ListBillingCountriesRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.billing.v1beta1.ListBillingCountriesRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListBillingCountriesRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut page_size__ = None;
                let mut page_token__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::PageSize => {
                            if page_size__.is_some() {
                                return Err(serde::de::Error::duplicate_field("pageSize"));
                            }
                            page_size__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::PageToken => {
                            if page_token__.is_some() {
                                return Err(serde::de::Error::duplicate_field("pageToken"));
                            }
                            page_token__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(ListBillingCountriesRequest {
                    page_size: page_size__.unwrap_or_default(),
                    page_token: page_token__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.ListBillingCountriesRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListBillingCountriesResponse {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.billing_countries.is_empty() {
            len += 1;
        }
        if !self.next_page_token.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.billing.v1beta1.ListBillingCountriesResponse",
                len,
            )?;
        if !self.billing_countries.is_empty() {
            struct_ser.serialize_field("billingCountries", &self.billing_countries)?;
        }
        if !self.next_page_token.is_empty() {
            struct_ser.serialize_field("nextPageToken", &self.next_page_token)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ListBillingCountriesResponse {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "billing_countries",
            "billingCountries",
            "next_page_token",
            "nextPageToken",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            BillingCountries,
            NextPageToken,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "billingCountries" | "billing_countries" => {
                                Ok(GeneratedField::BillingCountries)
                            }
                            "nextPageToken" | "next_page_token" => {
                                Ok(GeneratedField::NextPageToken)
                            }
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = ListBillingCountriesResponse;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.billing.v1beta1.ListBillingCountriesResponse",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListBillingCountriesResponse, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut billing_countries__ = None;
                let mut next_page_token__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::BillingCountries => {
                            if billing_countries__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("billingCountries"),
                                );
                            }
                            billing_countries__ = Some(map_.next_value()?);
                        }
                        GeneratedField::NextPageToken => {
                            if next_page_token__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("nextPageToken"),
                                );
                            }
                            next_page_token__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(ListBillingCountriesResponse {
                    billing_countries: billing_countries__.unwrap_or_default(),
                    next_page_token: next_page_token__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.ListBillingCountriesResponse",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListProjectBillingInfoRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.name.is_empty() {
            len += 1;
        }
        if self.page_size != 0 {
            len += 1;
        }
        if !self.page_token.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.billing.v1beta1.ListProjectBillingInfoRequest",
                len,
            )?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        if self.page_size != 0 {
            struct_ser.serialize_field("pageSize", &self.page_size)?;
        }
        if !self.page_token.is_empty() {
            struct_ser.serialize_field("pageToken", &self.page_token)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ListProjectBillingInfoRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "name",
            "page_size",
            "pageSize",
            "page_token",
            "pageToken",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            PageSize,
            PageToken,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "name" => Ok(GeneratedField::Name),
                            "pageSize" | "page_size" => Ok(GeneratedField::PageSize),
                            "pageToken" | "page_token" => Ok(GeneratedField::PageToken),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = ListProjectBillingInfoRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.billing.v1beta1.ListProjectBillingInfoRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListProjectBillingInfoRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                let mut page_size__ = None;
                let mut page_token__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Name => {
                            if name__.is_some() {
                                return Err(serde::de::Error::duplicate_field("name"));
                            }
                            name__ = Some(map_.next_value()?);
                        }
                        GeneratedField::PageSize => {
                            if page_size__.is_some() {
                                return Err(serde::de::Error::duplicate_field("pageSize"));
                            }
                            page_size__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::PageToken => {
                            if page_token__.is_some() {
                                return Err(serde::de::Error::duplicate_field("pageToken"));
                            }
                            page_token__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(ListProjectBillingInfoRequest {
                    name: name__.unwrap_or_default(),
                    page_size: page_size__.unwrap_or_default(),
                    page_token: page_token__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.ListProjectBillingInfoRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListProjectBillingInfoResponse {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.project_billing_infos.is_empty() {
            len += 1;
        }
        if !self.next_page_token.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.billing.v1beta1.ListProjectBillingInfoResponse",
                len,
            )?;
        if !self.project_billing_infos.is_empty() {
            struct_ser
                .serialize_field("projectBillingInfos", &self.project_billing_infos)?;
        }
        if !self.next_page_token.is_empty() {
            struct_ser.serialize_field("nextPageToken", &self.next_page_token)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ListProjectBillingInfoResponse {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "project_billing_infos",
            "projectBillingInfos",
            "next_page_token",
            "nextPageToken",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            ProjectBillingInfos,
            NextPageToken,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "projectBillingInfos" | "project_billing_infos" => {
                                Ok(GeneratedField::ProjectBillingInfos)
                            }
                            "nextPageToken" | "next_page_token" => {
                                Ok(GeneratedField::NextPageToken)
                            }
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = ListProjectBillingInfoResponse;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.billing.v1beta1.ListProjectBillingInfoResponse",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListProjectBillingInfoResponse, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut project_billing_infos__ = None;
                let mut next_page_token__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::ProjectBillingInfos => {
                            if project_billing_infos__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("projectBillingInfos"),
                                );
                            }
                            project_billing_infos__ = Some(map_.next_value()?);
                        }
                        GeneratedField::NextPageToken => {
                            if next_page_token__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("nextPageToken"),
                                );
                            }
                            next_page_token__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(ListProjectBillingInfoResponse {
                    project_billing_infos: project_billing_infos__.unwrap_or_default(),
                    next_page_token: next_page_token__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.ListProjectBillingInfoResponse",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for OrganizationCostReport {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.total.is_empty() {
            len += 1;
        }
        if !self.services.is_empty() {
            len += 1;
        }
        if !self.projects.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.billing.v1beta1.OrganizationCostReport",
                len,
            )?;
        if !self.total.is_empty() {
            struct_ser.serialize_field("total", &self.total)?;
        }
        if !self.services.is_empty() {
            struct_ser.serialize_field("services", &self.services)?;
        }
        if !self.projects.is_empty() {
            struct_ser.serialize_field("projects", &self.projects)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for OrganizationCostReport {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["total", "services", "projects"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Total,
            Services,
            Projects,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "total" => Ok(GeneratedField::Total),
                            "services" => Ok(GeneratedField::Services),
                            "projects" => Ok(GeneratedField::Projects),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = OrganizationCostReport;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.billing.v1beta1.OrganizationCostReport",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<OrganizationCostReport, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut total__ = None;
                let mut services__ = None;
                let mut projects__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Total => {
                            if total__.is_some() {
                                return Err(serde::de::Error::duplicate_field("total"));
                            }
                            total__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Services => {
                            if services__.is_some() {
                                return Err(serde::de::Error::duplicate_field("services"));
                            }
                            services__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Projects => {
                            if projects__.is_some() {
                                return Err(serde::de::Error::duplicate_field("projects"));
                            }
                            projects__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(OrganizationCostReport {
                    total: total__.unwrap_or_default(),
                    services: services__.unwrap_or_default(),
                    projects: projects__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.OrganizationCostReport",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for PaymentMethod {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if self.state != 0 {
            len += 1;
        }
        if !self.card_brand.is_empty() {
            len += 1;
        }
        if !self.card_last4.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.billing.v1beta1.PaymentMethod", len)?;
        if self.state != 0 {
            let v = payment_method::State::try_from(self.state)
                .map_err(|_| serde::ser::Error::custom(
                    format!("Invalid variant {}", self.state),
                ))?;
            struct_ser.serialize_field("state", &v)?;
        }
        if !self.card_brand.is_empty() {
            struct_ser.serialize_field("cardBrand", &self.card_brand)?;
        }
        if !self.card_last4.is_empty() {
            struct_ser.serialize_field("cardLast4", &self.card_last4)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for PaymentMethod {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "state",
            "card_brand",
            "cardBrand",
            "card_last4",
            "cardLast4",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            State,
            CardBrand,
            CardLast4,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "state" => Ok(GeneratedField::State),
                            "cardBrand" | "card_brand" => Ok(GeneratedField::CardBrand),
                            "cardLast4" | "card_last4" => Ok(GeneratedField::CardLast4),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = PaymentMethod;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.billing.v1beta1.PaymentMethod")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<PaymentMethod, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut state__ = None;
                let mut card_brand__ = None;
                let mut card_last4__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::State => {
                            if state__.is_some() {
                                return Err(serde::de::Error::duplicate_field("state"));
                            }
                            state__ = Some(
                                map_.next_value::<payment_method::State>()? as i32,
                            );
                        }
                        GeneratedField::CardBrand => {
                            if card_brand__.is_some() {
                                return Err(serde::de::Error::duplicate_field("cardBrand"));
                            }
                            card_brand__ = Some(map_.next_value()?);
                        }
                        GeneratedField::CardLast4 => {
                            if card_last4__.is_some() {
                                return Err(serde::de::Error::duplicate_field("cardLast4"));
                            }
                            card_last4__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(PaymentMethod {
                    state: state__.unwrap_or_default(),
                    card_brand: card_brand__.unwrap_or_default(),
                    card_last4: card_last4__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.PaymentMethod",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for payment_method::State {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        let variant = match self {
            Self::Unspecified => "STATE_UNSPECIFIED",
            Self::Missing => "MISSING",
            Self::Verified => "VERIFIED",
            Self::NotRequired => "NOT_REQUIRED",
        };
        serializer.serialize_str(variant)
    }
}
impl<'de> serde::Deserialize<'de> for payment_method::State {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "STATE_UNSPECIFIED",
            "MISSING",
            "VERIFIED",
            "NOT_REQUIRED",
        ];
        struct GeneratedVisitor;
        impl serde::de::Visitor<'_> for GeneratedVisitor {
            type Value = payment_method::State;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                write!(formatter, "expected one of: {:?}", & FIELDS)
            }
            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
            where
                E: serde::de::Error,
            {
                i32::try_from(v)
                    .ok()
                    .and_then(|x| {
                        x
                            .try_into()
                            .ok()
                            .or_else(|| Some(payment_method::State::default()))
                    })
                    .ok_or_else(|| {
                        serde::de::Error::invalid_value(
                            serde::de::Unexpected::Signed(v),
                            &self,
                        )
                    })
            }
            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
            where
                E: serde::de::Error,
            {
                i32::try_from(v)
                    .ok()
                    .and_then(|x| {
                        x
                            .try_into()
                            .ok()
                            .or_else(|| Some(payment_method::State::default()))
                    })
                    .ok_or_else(|| {
                        serde::de::Error::invalid_value(
                            serde::de::Unexpected::Unsigned(v),
                            &self,
                        )
                    })
            }
            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
            where
                E: serde::de::Error,
            {
                match value {
                    "STATE_UNSPECIFIED" => Ok(payment_method::State::Unspecified),
                    "MISSING" => Ok(payment_method::State::Missing),
                    "VERIFIED" => Ok(payment_method::State::Verified),
                    "NOT_REQUIRED" => Ok(payment_method::State::NotRequired),
                    _ => Ok(payment_method::State::default()),
                }
            }
        }
        deserializer.deserialize_any(GeneratedVisitor)
    }
}
impl serde::Serialize for Price {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.product_key.is_empty() {
            len += 1;
        }
        if !self.dimensions.is_empty() {
            len += 1;
        }
        if !self.unit_type.is_empty() {
            len += 1;
        }
        if self.unit_count != 0 {
            len += 1;
        }
        if !self.amount.is_empty() {
            len += 1;
        }
        if self.valid_from.is_some() {
            len += 1;
        }
        if self.valid_until.is_some() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.billing.v1beta1.Price", len)?;
        if !self.product_key.is_empty() {
            struct_ser.serialize_field("product_key", &self.product_key)?;
        }
        if !self.dimensions.is_empty() {
            struct_ser.serialize_field("dimensions", &self.dimensions)?;
        }
        if !self.unit_type.is_empty() {
            struct_ser.serialize_field("unit_type", &self.unit_type)?;
        }
        if self.unit_count != 0 {
            struct_ser.serialize_field("unit_count", &self.unit_count)?;
        }
        if !self.amount.is_empty() {
            struct_ser.serialize_field("amount", &self.amount)?;
        }
        if let Some(v) = self.valid_from.as_ref() {
            struct_ser.serialize_field("valid_from", v)?;
        }
        if let Some(v) = self.valid_until.as_ref() {
            struct_ser.serialize_field("valid_until", v)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for Price {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "product_key",
            "dimensions",
            "unit_type",
            "unit_count",
            "amount",
            "valid_from",
            "valid_until",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            ProductKey,
            Dimensions,
            UnitType,
            UnitCount,
            Amount,
            ValidFrom,
            ValidUntil,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "product_key" => Ok(GeneratedField::ProductKey),
                            "dimensions" => Ok(GeneratedField::Dimensions),
                            "unit_type" => Ok(GeneratedField::UnitType),
                            "unit_count" => Ok(GeneratedField::UnitCount),
                            "amount" => Ok(GeneratedField::Amount),
                            "valid_from" => Ok(GeneratedField::ValidFrom),
                            "valid_until" => Ok(GeneratedField::ValidUntil),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = Price;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.billing.v1beta1.Price")
            }
            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Price, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut product_key__ = None;
                let mut dimensions__ = None;
                let mut unit_type__ = None;
                let mut unit_count__ = None;
                let mut amount__ = None;
                let mut valid_from__ = None;
                let mut valid_until__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::ProductKey => {
                            if product_key__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("product_key"),
                                );
                            }
                            product_key__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Dimensions => {
                            if dimensions__.is_some() {
                                return Err(serde::de::Error::duplicate_field("dimensions"));
                            }
                            dimensions__ = Some(
                                map_.next_value::<std::collections::BTreeMap<_, _>>()?,
                            );
                        }
                        GeneratedField::UnitType => {
                            if unit_type__.is_some() {
                                return Err(serde::de::Error::duplicate_field("unit_type"));
                            }
                            unit_type__ = Some(map_.next_value()?);
                        }
                        GeneratedField::UnitCount => {
                            if unit_count__.is_some() {
                                return Err(serde::de::Error::duplicate_field("unit_count"));
                            }
                            unit_count__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::Amount => {
                            if amount__.is_some() {
                                return Err(serde::de::Error::duplicate_field("amount"));
                            }
                            amount__ = Some(map_.next_value()?);
                        }
                        GeneratedField::ValidFrom => {
                            if valid_from__.is_some() {
                                return Err(serde::de::Error::duplicate_field("valid_from"));
                            }
                            valid_from__ = map_.next_value()?;
                        }
                        GeneratedField::ValidUntil => {
                            if valid_until__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("valid_until"),
                                );
                            }
                            valid_until__ = map_.next_value()?;
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(Price {
                    product_key: product_key__.unwrap_or_default(),
                    dimensions: dimensions__.unwrap_or_default(),
                    unit_type: unit_type__.unwrap_or_default(),
                    unit_count: unit_count__.unwrap_or_default(),
                    amount: amount__.unwrap_or_default(),
                    valid_from: valid_from__,
                    valid_until: valid_until__,
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.Price",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for PriceFamily {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.family.is_empty() {
            len += 1;
        }
        if !self.prices.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.billing.v1beta1.PriceFamily", len)?;
        if !self.family.is_empty() {
            struct_ser.serialize_field("family", &self.family)?;
        }
        if !self.prices.is_empty() {
            struct_ser.serialize_field("prices", &self.prices)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for PriceFamily {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["family", "prices"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Family,
            Prices,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "family" => Ok(GeneratedField::Family),
                            "prices" => Ok(GeneratedField::Prices),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = PriceFamily;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.billing.v1beta1.PriceFamily")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<PriceFamily, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut family__ = None;
                let mut prices__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Family => {
                            if family__.is_some() {
                                return Err(serde::de::Error::duplicate_field("family"));
                            }
                            family__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Prices => {
                            if prices__.is_some() {
                                return Err(serde::de::Error::duplicate_field("prices"));
                            }
                            prices__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(PriceFamily {
                    family: family__.unwrap_or_default(),
                    prices: prices__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.PriceFamily",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for PriceList {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.currency.is_empty() {
            len += 1;
        }
        if self.amounts_exclude_vat {
            len += 1;
        }
        if self.last_changed.is_some() {
            len += 1;
        }
        if !self.families.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.billing.v1beta1.PriceList", len)?;
        if !self.currency.is_empty() {
            struct_ser.serialize_field("currency", &self.currency)?;
        }
        if self.amounts_exclude_vat {
            struct_ser
                .serialize_field("amounts_exclude_vat", &self.amounts_exclude_vat)?;
        }
        if let Some(v) = self.last_changed.as_ref() {
            struct_ser.serialize_field("last_changed", v)?;
        }
        if !self.families.is_empty() {
            struct_ser.serialize_field("families", &self.families)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for PriceList {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "currency",
            "amounts_exclude_vat",
            "last_changed",
            "families",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Currency,
            AmountsExcludeVat,
            LastChanged,
            Families,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "currency" => Ok(GeneratedField::Currency),
                            "amounts_exclude_vat" => {
                                Ok(GeneratedField::AmountsExcludeVat)
                            }
                            "last_changed" => Ok(GeneratedField::LastChanged),
                            "families" => Ok(GeneratedField::Families),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = PriceList;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.billing.v1beta1.PriceList")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<PriceList, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut currency__ = None;
                let mut amounts_exclude_vat__ = None;
                let mut last_changed__ = None;
                let mut families__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Currency => {
                            if currency__.is_some() {
                                return Err(serde::de::Error::duplicate_field("currency"));
                            }
                            currency__ = Some(map_.next_value()?);
                        }
                        GeneratedField::AmountsExcludeVat => {
                            if amounts_exclude_vat__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("amounts_exclude_vat"),
                                );
                            }
                            amounts_exclude_vat__ = Some(map_.next_value()?);
                        }
                        GeneratedField::LastChanged => {
                            if last_changed__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("last_changed"),
                                );
                            }
                            last_changed__ = map_.next_value()?;
                        }
                        GeneratedField::Families => {
                            if families__.is_some() {
                                return Err(serde::de::Error::duplicate_field("families"));
                            }
                            families__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(PriceList {
                    currency: currency__.unwrap_or_default(),
                    amounts_exclude_vat: amounts_exclude_vat__.unwrap_or_default(),
                    last_changed: last_changed__,
                    families: families__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.PriceList",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ProductCost {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.product_key.is_empty() {
            len += 1;
        }
        if !self.total.is_empty() {
            len += 1;
        }
        if !self.buckets.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.billing.v1beta1.ProductCost", len)?;
        if !self.product_key.is_empty() {
            struct_ser.serialize_field("productKey", &self.product_key)?;
        }
        if !self.total.is_empty() {
            struct_ser.serialize_field("total", &self.total)?;
        }
        if !self.buckets.is_empty() {
            struct_ser.serialize_field("buckets", &self.buckets)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ProductCost {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["product_key", "productKey", "total", "buckets"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            ProductKey,
            Total,
            Buckets,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "productKey" | "product_key" => {
                                Ok(GeneratedField::ProductKey)
                            }
                            "total" => Ok(GeneratedField::Total),
                            "buckets" => Ok(GeneratedField::Buckets),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = ProductCost;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.billing.v1beta1.ProductCost")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ProductCost, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut product_key__ = None;
                let mut total__ = None;
                let mut buckets__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::ProductKey => {
                            if product_key__.is_some() {
                                return Err(serde::de::Error::duplicate_field("productKey"));
                            }
                            product_key__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Total => {
                            if total__.is_some() {
                                return Err(serde::de::Error::duplicate_field("total"));
                            }
                            total__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Buckets => {
                            if buckets__.is_some() {
                                return Err(serde::de::Error::duplicate_field("buckets"));
                            }
                            buckets__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(ProductCost {
                    product_key: product_key__.unwrap_or_default(),
                    total: total__.unwrap_or_default(),
                    buckets: buckets__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.ProductCost",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ProjectBillingInfo {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.name.is_empty() {
            len += 1;
        }
        if !self.billing_account.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.billing.v1beta1.ProjectBillingInfo", len)?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        if !self.billing_account.is_empty() {
            struct_ser.serialize_field("billingAccount", &self.billing_account)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ProjectBillingInfo {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["name", "billing_account", "billingAccount"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            BillingAccount,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "name" => Ok(GeneratedField::Name),
                            "billingAccount" | "billing_account" => {
                                Ok(GeneratedField::BillingAccount)
                            }
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = ProjectBillingInfo;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.billing.v1beta1.ProjectBillingInfo")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ProjectBillingInfo, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                let mut billing_account__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Name => {
                            if name__.is_some() {
                                return Err(serde::de::Error::duplicate_field("name"));
                            }
                            name__ = Some(map_.next_value()?);
                        }
                        GeneratedField::BillingAccount => {
                            if billing_account__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("billingAccount"),
                                );
                            }
                            billing_account__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(ProjectBillingInfo {
                    name: name__.unwrap_or_default(),
                    billing_account: billing_account__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.ProjectBillingInfo",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ProjectCost {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.project.is_empty() {
            len += 1;
        }
        if !self.total.is_empty() {
            len += 1;
        }
        if !self.buckets.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.billing.v1beta1.ProjectCost", len)?;
        if !self.project.is_empty() {
            struct_ser.serialize_field("project", &self.project)?;
        }
        if !self.total.is_empty() {
            struct_ser.serialize_field("total", &self.total)?;
        }
        if !self.buckets.is_empty() {
            struct_ser.serialize_field("buckets", &self.buckets)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ProjectCost {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["project", "total", "buckets"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Project,
            Total,
            Buckets,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "project" => Ok(GeneratedField::Project),
                            "total" => Ok(GeneratedField::Total),
                            "buckets" => Ok(GeneratedField::Buckets),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = ProjectCost;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.billing.v1beta1.ProjectCost")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ProjectCost, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut project__ = None;
                let mut total__ = None;
                let mut buckets__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Project => {
                            if project__.is_some() {
                                return Err(serde::de::Error::duplicate_field("project"));
                            }
                            project__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Total => {
                            if total__.is_some() {
                                return Err(serde::de::Error::duplicate_field("total"));
                            }
                            total__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Buckets => {
                            if buckets__.is_some() {
                                return Err(serde::de::Error::duplicate_field("buckets"));
                            }
                            buckets__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(ProjectCost {
                    project: project__.unwrap_or_default(),
                    total: total__.unwrap_or_default(),
                    buckets: buckets__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.ProjectCost",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for QueryBillingAccountCostRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.billing_account.is_empty() {
            len += 1;
        }
        if self.start_time.is_some() {
            len += 1;
        }
        if self.end_time.is_some() {
            len += 1;
        }
        if self.granularity != 0 {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.billing.v1beta1.QueryBillingAccountCostRequest",
                len,
            )?;
        if !self.billing_account.is_empty() {
            struct_ser.serialize_field("billingAccount", &self.billing_account)?;
        }
        if let Some(v) = self.start_time.as_ref() {
            struct_ser.serialize_field("startTime", v)?;
        }
        if let Some(v) = self.end_time.as_ref() {
            struct_ser.serialize_field("endTime", v)?;
        }
        if self.granularity != 0 {
            let v = Granularity::try_from(self.granularity)
                .map_err(|_| serde::ser::Error::custom(
                    format!("Invalid variant {}", self.granularity),
                ))?;
            struct_ser.serialize_field("granularity", &v)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for QueryBillingAccountCostRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "billing_account",
            "billingAccount",
            "start_time",
            "startTime",
            "end_time",
            "endTime",
            "granularity",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            BillingAccount,
            StartTime,
            EndTime,
            Granularity,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "billingAccount" | "billing_account" => {
                                Ok(GeneratedField::BillingAccount)
                            }
                            "startTime" | "start_time" => Ok(GeneratedField::StartTime),
                            "endTime" | "end_time" => Ok(GeneratedField::EndTime),
                            "granularity" => Ok(GeneratedField::Granularity),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = QueryBillingAccountCostRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.billing.v1beta1.QueryBillingAccountCostRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<QueryBillingAccountCostRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut billing_account__ = None;
                let mut start_time__ = None;
                let mut end_time__ = None;
                let mut granularity__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::BillingAccount => {
                            if billing_account__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("billingAccount"),
                                );
                            }
                            billing_account__ = Some(map_.next_value()?);
                        }
                        GeneratedField::StartTime => {
                            if start_time__.is_some() {
                                return Err(serde::de::Error::duplicate_field("startTime"));
                            }
                            start_time__ = map_.next_value()?;
                        }
                        GeneratedField::EndTime => {
                            if end_time__.is_some() {
                                return Err(serde::de::Error::duplicate_field("endTime"));
                            }
                            end_time__ = map_.next_value()?;
                        }
                        GeneratedField::Granularity => {
                            if granularity__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("granularity"),
                                );
                            }
                            granularity__ = Some(
                                map_.next_value::<Granularity>()? as i32,
                            );
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(QueryBillingAccountCostRequest {
                    billing_account: billing_account__.unwrap_or_default(),
                    start_time: start_time__,
                    end_time: end_time__,
                    granularity: granularity__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.QueryBillingAccountCostRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for QueryOrganizationCostRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.organization.is_empty() {
            len += 1;
        }
        if self.start_time.is_some() {
            len += 1;
        }
        if self.end_time.is_some() {
            len += 1;
        }
        if self.granularity != 0 {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.billing.v1beta1.QueryOrganizationCostRequest",
                len,
            )?;
        if !self.organization.is_empty() {
            struct_ser.serialize_field("organization", &self.organization)?;
        }
        if let Some(v) = self.start_time.as_ref() {
            struct_ser.serialize_field("startTime", v)?;
        }
        if let Some(v) = self.end_time.as_ref() {
            struct_ser.serialize_field("endTime", v)?;
        }
        if self.granularity != 0 {
            let v = Granularity::try_from(self.granularity)
                .map_err(|_| serde::ser::Error::custom(
                    format!("Invalid variant {}", self.granularity),
                ))?;
            struct_ser.serialize_field("granularity", &v)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for QueryOrganizationCostRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "organization",
            "start_time",
            "startTime",
            "end_time",
            "endTime",
            "granularity",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Organization,
            StartTime,
            EndTime,
            Granularity,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "organization" => Ok(GeneratedField::Organization),
                            "startTime" | "start_time" => Ok(GeneratedField::StartTime),
                            "endTime" | "end_time" => Ok(GeneratedField::EndTime),
                            "granularity" => Ok(GeneratedField::Granularity),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = QueryOrganizationCostRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.billing.v1beta1.QueryOrganizationCostRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<QueryOrganizationCostRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut organization__ = None;
                let mut start_time__ = None;
                let mut end_time__ = None;
                let mut granularity__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Organization => {
                            if organization__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("organization"),
                                );
                            }
                            organization__ = Some(map_.next_value()?);
                        }
                        GeneratedField::StartTime => {
                            if start_time__.is_some() {
                                return Err(serde::de::Error::duplicate_field("startTime"));
                            }
                            start_time__ = map_.next_value()?;
                        }
                        GeneratedField::EndTime => {
                            if end_time__.is_some() {
                                return Err(serde::de::Error::duplicate_field("endTime"));
                            }
                            end_time__ = map_.next_value()?;
                        }
                        GeneratedField::Granularity => {
                            if granularity__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("granularity"),
                                );
                            }
                            granularity__ = Some(
                                map_.next_value::<Granularity>()? as i32,
                            );
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(QueryOrganizationCostRequest {
                    organization: organization__.unwrap_or_default(),
                    start_time: start_time__,
                    end_time: end_time__,
                    granularity: granularity__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.QueryOrganizationCostRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for QueryProjectCostRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.project.is_empty() {
            len += 1;
        }
        if self.start_time.is_some() {
            len += 1;
        }
        if self.end_time.is_some() {
            len += 1;
        }
        if self.granularity != 0 {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.billing.v1beta1.QueryProjectCostRequest",
                len,
            )?;
        if !self.project.is_empty() {
            struct_ser.serialize_field("project", &self.project)?;
        }
        if let Some(v) = self.start_time.as_ref() {
            struct_ser.serialize_field("startTime", v)?;
        }
        if let Some(v) = self.end_time.as_ref() {
            struct_ser.serialize_field("endTime", v)?;
        }
        if self.granularity != 0 {
            let v = Granularity::try_from(self.granularity)
                .map_err(|_| serde::ser::Error::custom(
                    format!("Invalid variant {}", self.granularity),
                ))?;
            struct_ser.serialize_field("granularity", &v)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for QueryProjectCostRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "project",
            "start_time",
            "startTime",
            "end_time",
            "endTime",
            "granularity",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Project,
            StartTime,
            EndTime,
            Granularity,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "project" => Ok(GeneratedField::Project),
                            "startTime" | "start_time" => Ok(GeneratedField::StartTime),
                            "endTime" | "end_time" => Ok(GeneratedField::EndTime),
                            "granularity" => Ok(GeneratedField::Granularity),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = QueryProjectCostRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.billing.v1beta1.QueryProjectCostRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<QueryProjectCostRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut project__ = None;
                let mut start_time__ = None;
                let mut end_time__ = None;
                let mut granularity__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Project => {
                            if project__.is_some() {
                                return Err(serde::de::Error::duplicate_field("project"));
                            }
                            project__ = Some(map_.next_value()?);
                        }
                        GeneratedField::StartTime => {
                            if start_time__.is_some() {
                                return Err(serde::de::Error::duplicate_field("startTime"));
                            }
                            start_time__ = map_.next_value()?;
                        }
                        GeneratedField::EndTime => {
                            if end_time__.is_some() {
                                return Err(serde::de::Error::duplicate_field("endTime"));
                            }
                            end_time__ = map_.next_value()?;
                        }
                        GeneratedField::Granularity => {
                            if granularity__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("granularity"),
                                );
                            }
                            granularity__ = Some(
                                map_.next_value::<Granularity>()? as i32,
                            );
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(QueryProjectCostRequest {
                    project: project__.unwrap_or_default(),
                    start_time: start_time__,
                    end_time: end_time__,
                    granularity: granularity__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.QueryProjectCostRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for QueryProjectUsageRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.project.is_empty() {
            len += 1;
        }
        if self.start_time.is_some() {
            len += 1;
        }
        if self.end_time.is_some() {
            len += 1;
        }
        if self.page_size != 0 {
            len += 1;
        }
        if !self.page_token.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.billing.v1beta1.QueryProjectUsageRequest",
                len,
            )?;
        if !self.project.is_empty() {
            struct_ser.serialize_field("project", &self.project)?;
        }
        if let Some(v) = self.start_time.as_ref() {
            struct_ser.serialize_field("startTime", v)?;
        }
        if let Some(v) = self.end_time.as_ref() {
            struct_ser.serialize_field("endTime", v)?;
        }
        if self.page_size != 0 {
            struct_ser.serialize_field("pageSize", &self.page_size)?;
        }
        if !self.page_token.is_empty() {
            struct_ser.serialize_field("pageToken", &self.page_token)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for QueryProjectUsageRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "project",
            "start_time",
            "startTime",
            "end_time",
            "endTime",
            "page_size",
            "pageSize",
            "page_token",
            "pageToken",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Project,
            StartTime,
            EndTime,
            PageSize,
            PageToken,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "project" => Ok(GeneratedField::Project),
                            "startTime" | "start_time" => Ok(GeneratedField::StartTime),
                            "endTime" | "end_time" => Ok(GeneratedField::EndTime),
                            "pageSize" | "page_size" => Ok(GeneratedField::PageSize),
                            "pageToken" | "page_token" => Ok(GeneratedField::PageToken),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = QueryProjectUsageRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.billing.v1beta1.QueryProjectUsageRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<QueryProjectUsageRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut project__ = None;
                let mut start_time__ = None;
                let mut end_time__ = None;
                let mut page_size__ = None;
                let mut page_token__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Project => {
                            if project__.is_some() {
                                return Err(serde::de::Error::duplicate_field("project"));
                            }
                            project__ = Some(map_.next_value()?);
                        }
                        GeneratedField::StartTime => {
                            if start_time__.is_some() {
                                return Err(serde::de::Error::duplicate_field("startTime"));
                            }
                            start_time__ = map_.next_value()?;
                        }
                        GeneratedField::EndTime => {
                            if end_time__.is_some() {
                                return Err(serde::de::Error::duplicate_field("endTime"));
                            }
                            end_time__ = map_.next_value()?;
                        }
                        GeneratedField::PageSize => {
                            if page_size__.is_some() {
                                return Err(serde::de::Error::duplicate_field("pageSize"));
                            }
                            page_size__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::PageToken => {
                            if page_token__.is_some() {
                                return Err(serde::de::Error::duplicate_field("pageToken"));
                            }
                            page_token__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(QueryProjectUsageRequest {
                    project: project__.unwrap_or_default(),
                    start_time: start_time__,
                    end_time: end_time__,
                    page_size: page_size__.unwrap_or_default(),
                    page_token: page_token__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.QueryProjectUsageRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for QueryProjectUsageResponse {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.usage_records.is_empty() {
            len += 1;
        }
        if !self.next_page_token.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.billing.v1beta1.QueryProjectUsageResponse",
                len,
            )?;
        if !self.usage_records.is_empty() {
            struct_ser.serialize_field("usageRecords", &self.usage_records)?;
        }
        if !self.next_page_token.is_empty() {
            struct_ser.serialize_field("nextPageToken", &self.next_page_token)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for QueryProjectUsageResponse {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "usage_records",
            "usageRecords",
            "next_page_token",
            "nextPageToken",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            UsageRecords,
            NextPageToken,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "usageRecords" | "usage_records" => {
                                Ok(GeneratedField::UsageRecords)
                            }
                            "nextPageToken" | "next_page_token" => {
                                Ok(GeneratedField::NextPageToken)
                            }
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = QueryProjectUsageResponse;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.billing.v1beta1.QueryProjectUsageResponse",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<QueryProjectUsageResponse, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut usage_records__ = None;
                let mut next_page_token__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::UsageRecords => {
                            if usage_records__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("usageRecords"),
                                );
                            }
                            usage_records__ = Some(map_.next_value()?);
                        }
                        GeneratedField::NextPageToken => {
                            if next_page_token__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("nextPageToken"),
                                );
                            }
                            next_page_token__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(QueryProjectUsageResponse {
                    usage_records: usage_records__.unwrap_or_default(),
                    next_page_token: next_page_token__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.QueryProjectUsageResponse",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ServiceCost {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.service.is_empty() {
            len += 1;
        }
        if !self.total.is_empty() {
            len += 1;
        }
        if !self.products.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.billing.v1beta1.ServiceCost", len)?;
        if !self.service.is_empty() {
            struct_ser.serialize_field("service", &self.service)?;
        }
        if !self.total.is_empty() {
            struct_ser.serialize_field("total", &self.total)?;
        }
        if !self.products.is_empty() {
            struct_ser.serialize_field("products", &self.products)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ServiceCost {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["service", "total", "products"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Service,
            Total,
            Products,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "service" => Ok(GeneratedField::Service),
                            "total" => Ok(GeneratedField::Total),
                            "products" => Ok(GeneratedField::Products),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = ServiceCost;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.billing.v1beta1.ServiceCost")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ServiceCost, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut service__ = None;
                let mut total__ = None;
                let mut products__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Service => {
                            if service__.is_some() {
                                return Err(serde::de::Error::duplicate_field("service"));
                            }
                            service__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Total => {
                            if total__.is_some() {
                                return Err(serde::de::Error::duplicate_field("total"));
                            }
                            total__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Products => {
                            if products__.is_some() {
                                return Err(serde::de::Error::duplicate_field("products"));
                            }
                            products__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(ServiceCost {
                    service: service__.unwrap_or_default(),
                    total: total__.unwrap_or_default(),
                    products: products__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.ServiceCost",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for SpendLimit {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.name.is_empty() {
            len += 1;
        }
        if self.limit.is_some() {
            len += 1;
        }
        if !self.alert_thresholds_percent.is_empty() {
            len += 1;
        }
        if !self.notification_emails.is_empty() {
            len += 1;
        }
        if self.update_time.is_some() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.billing.v1beta1.SpendLimit", len)?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        if let Some(v) = self.limit.as_ref() {
            struct_ser.serialize_field("limit", v)?;
        }
        if !self.alert_thresholds_percent.is_empty() {
            struct_ser
                .serialize_field(
                    "alertThresholdsPercent",
                    &self.alert_thresholds_percent,
                )?;
        }
        if !self.notification_emails.is_empty() {
            struct_ser.serialize_field("notificationEmails", &self.notification_emails)?;
        }
        if let Some(v) = self.update_time.as_ref() {
            struct_ser.serialize_field("updateTime", v)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for SpendLimit {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "name",
            "limit",
            "alert_thresholds_percent",
            "alertThresholdsPercent",
            "notification_emails",
            "notificationEmails",
            "update_time",
            "updateTime",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            Limit,
            AlertThresholdsPercent,
            NotificationEmails,
            UpdateTime,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "name" => Ok(GeneratedField::Name),
                            "limit" => Ok(GeneratedField::Limit),
                            "alertThresholdsPercent" | "alert_thresholds_percent" => {
                                Ok(GeneratedField::AlertThresholdsPercent)
                            }
                            "notificationEmails" | "notification_emails" => {
                                Ok(GeneratedField::NotificationEmails)
                            }
                            "updateTime" | "update_time" => {
                                Ok(GeneratedField::UpdateTime)
                            }
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = SpendLimit;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.billing.v1beta1.SpendLimit")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<SpendLimit, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                let mut limit__ = None;
                let mut alert_thresholds_percent__ = None;
                let mut notification_emails__ = None;
                let mut update_time__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Name => {
                            if name__.is_some() {
                                return Err(serde::de::Error::duplicate_field("name"));
                            }
                            name__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Limit => {
                            if limit__.is_some() {
                                return Err(serde::de::Error::duplicate_field("limit"));
                            }
                            limit__ = map_.next_value()?;
                        }
                        GeneratedField::AlertThresholdsPercent => {
                            if alert_thresholds_percent__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("alertThresholdsPercent"),
                                );
                            }
                            alert_thresholds_percent__ = Some(
                                map_
                                    .next_value::<
                                        Vec<::pbjson::private::NumberDeserialize<_>>,
                                    >()?
                                    .into_iter()
                                    .map(|x| x.0)
                                    .collect(),
                            );
                        }
                        GeneratedField::NotificationEmails => {
                            if notification_emails__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("notificationEmails"),
                                );
                            }
                            notification_emails__ = Some(map_.next_value()?);
                        }
                        GeneratedField::UpdateTime => {
                            if update_time__.is_some() {
                                return Err(serde::de::Error::duplicate_field("updateTime"));
                            }
                            update_time__ = map_.next_value()?;
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(SpendLimit {
                    name: name__.unwrap_or_default(),
                    limit: limit__,
                    alert_thresholds_percent: alert_thresholds_percent__
                        .unwrap_or_default(),
                    notification_emails: notification_emails__.unwrap_or_default(),
                    update_time: update_time__,
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.SpendLimit",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for StartPaymentMethodSetupRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.name.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.billing.v1beta1.StartPaymentMethodSetupRequest",
                len,
            )?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for StartPaymentMethodSetupRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["name"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "name" => Ok(GeneratedField::Name),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = StartPaymentMethodSetupRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.billing.v1beta1.StartPaymentMethodSetupRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<StartPaymentMethodSetupRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Name => {
                            if name__.is_some() {
                                return Err(serde::de::Error::duplicate_field("name"));
                            }
                            name__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(StartPaymentMethodSetupRequest {
                    name: name__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.StartPaymentMethodSetupRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for StartPaymentMethodSetupResponse {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.redirect_uri.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.billing.v1beta1.StartPaymentMethodSetupResponse",
                len,
            )?;
        if !self.redirect_uri.is_empty() {
            struct_ser.serialize_field("redirectUri", &self.redirect_uri)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for StartPaymentMethodSetupResponse {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["redirect_uri", "redirectUri"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            RedirectUri,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "redirectUri" | "redirect_uri" => {
                                Ok(GeneratedField::RedirectUri)
                            }
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = StartPaymentMethodSetupResponse;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.billing.v1beta1.StartPaymentMethodSetupResponse",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<StartPaymentMethodSetupResponse, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut redirect_uri__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::RedirectUri => {
                            if redirect_uri__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("redirectUri"),
                                );
                            }
                            redirect_uri__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(StartPaymentMethodSetupResponse {
                    redirect_uri: redirect_uri__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.StartPaymentMethodSetupResponse",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for UpdateBillingAccountRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if self.billing_account.is_some() {
            len += 1;
        }
        if self.update_mask.is_some() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.billing.v1beta1.UpdateBillingAccountRequest",
                len,
            )?;
        if let Some(v) = self.billing_account.as_ref() {
            struct_ser.serialize_field("billingAccount", v)?;
        }
        if let Some(v) = self.update_mask.as_ref() {
            struct_ser.serialize_field("updateMask", v)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for UpdateBillingAccountRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "billing_account",
            "billingAccount",
            "update_mask",
            "updateMask",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            BillingAccount,
            UpdateMask,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "billingAccount" | "billing_account" => {
                                Ok(GeneratedField::BillingAccount)
                            }
                            "updateMask" | "update_mask" => {
                                Ok(GeneratedField::UpdateMask)
                            }
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = UpdateBillingAccountRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.billing.v1beta1.UpdateBillingAccountRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<UpdateBillingAccountRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut billing_account__ = None;
                let mut update_mask__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::BillingAccount => {
                            if billing_account__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("billingAccount"),
                                );
                            }
                            billing_account__ = map_.next_value()?;
                        }
                        GeneratedField::UpdateMask => {
                            if update_mask__.is_some() {
                                return Err(serde::de::Error::duplicate_field("updateMask"));
                            }
                            update_mask__ = map_.next_value()?;
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(UpdateBillingAccountRequest {
                    billing_account: billing_account__,
                    update_mask: update_mask__,
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.UpdateBillingAccountRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for UpdateProjectBillingInfoRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if self.project_billing_info.is_some() {
            len += 1;
        }
        if self.update_mask.is_some() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.billing.v1beta1.UpdateProjectBillingInfoRequest",
                len,
            )?;
        if let Some(v) = self.project_billing_info.as_ref() {
            struct_ser.serialize_field("projectBillingInfo", v)?;
        }
        if let Some(v) = self.update_mask.as_ref() {
            struct_ser.serialize_field("updateMask", v)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for UpdateProjectBillingInfoRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "project_billing_info",
            "projectBillingInfo",
            "update_mask",
            "updateMask",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            ProjectBillingInfo,
            UpdateMask,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "projectBillingInfo" | "project_billing_info" => {
                                Ok(GeneratedField::ProjectBillingInfo)
                            }
                            "updateMask" | "update_mask" => {
                                Ok(GeneratedField::UpdateMask)
                            }
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = UpdateProjectBillingInfoRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.billing.v1beta1.UpdateProjectBillingInfoRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<UpdateProjectBillingInfoRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut project_billing_info__ = None;
                let mut update_mask__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::ProjectBillingInfo => {
                            if project_billing_info__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("projectBillingInfo"),
                                );
                            }
                            project_billing_info__ = map_.next_value()?;
                        }
                        GeneratedField::UpdateMask => {
                            if update_mask__.is_some() {
                                return Err(serde::de::Error::duplicate_field("updateMask"));
                            }
                            update_mask__ = map_.next_value()?;
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(UpdateProjectBillingInfoRequest {
                    project_billing_info: project_billing_info__,
                    update_mask: update_mask__,
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.UpdateProjectBillingInfoRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for UpdateSpendLimitRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if self.spend_limit.is_some() {
            len += 1;
        }
        if self.update_mask.is_some() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.billing.v1beta1.UpdateSpendLimitRequest",
                len,
            )?;
        if let Some(v) = self.spend_limit.as_ref() {
            struct_ser.serialize_field("spendLimit", v)?;
        }
        if let Some(v) = self.update_mask.as_ref() {
            struct_ser.serialize_field("updateMask", v)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for UpdateSpendLimitRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "spend_limit",
            "spendLimit",
            "update_mask",
            "updateMask",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            SpendLimit,
            UpdateMask,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "spendLimit" | "spend_limit" => {
                                Ok(GeneratedField::SpendLimit)
                            }
                            "updateMask" | "update_mask" => {
                                Ok(GeneratedField::UpdateMask)
                            }
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = UpdateSpendLimitRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.billing.v1beta1.UpdateSpendLimitRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<UpdateSpendLimitRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut spend_limit__ = None;
                let mut update_mask__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::SpendLimit => {
                            if spend_limit__.is_some() {
                                return Err(serde::de::Error::duplicate_field("spendLimit"));
                            }
                            spend_limit__ = map_.next_value()?;
                        }
                        GeneratedField::UpdateMask => {
                            if update_mask__.is_some() {
                                return Err(serde::de::Error::duplicate_field("updateMask"));
                            }
                            update_mask__ = map_.next_value()?;
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(UpdateSpendLimitRequest {
                    spend_limit: spend_limit__,
                    update_mask: update_mask__,
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.UpdateSpendLimitRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for UsageRecord {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.resource_kind.is_empty() {
            len += 1;
        }
        if !self.resource_id.is_empty() {
            len += 1;
        }
        if !self.metric.is_empty() {
            len += 1;
        }
        if !self.product_key.is_empty() {
            len += 1;
        }
        if !self.quantity.is_empty() {
            len += 1;
        }
        if self.start_time.is_some() {
            len += 1;
        }
        if self.end_time.is_some() {
            len += 1;
        }
        if !self.billing_account.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.billing.v1beta1.UsageRecord", len)?;
        if !self.resource_kind.is_empty() {
            struct_ser.serialize_field("resourceKind", &self.resource_kind)?;
        }
        if !self.resource_id.is_empty() {
            struct_ser.serialize_field("resourceId", &self.resource_id)?;
        }
        if !self.metric.is_empty() {
            struct_ser.serialize_field("metric", &self.metric)?;
        }
        if !self.product_key.is_empty() {
            struct_ser.serialize_field("productKey", &self.product_key)?;
        }
        if !self.quantity.is_empty() {
            struct_ser.serialize_field("quantity", &self.quantity)?;
        }
        if let Some(v) = self.start_time.as_ref() {
            struct_ser.serialize_field("startTime", v)?;
        }
        if let Some(v) = self.end_time.as_ref() {
            struct_ser.serialize_field("endTime", v)?;
        }
        if !self.billing_account.is_empty() {
            struct_ser.serialize_field("billingAccount", &self.billing_account)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for UsageRecord {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "resource_kind",
            "resourceKind",
            "resource_id",
            "resourceId",
            "metric",
            "product_key",
            "productKey",
            "quantity",
            "start_time",
            "startTime",
            "end_time",
            "endTime",
            "billing_account",
            "billingAccount",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            ResourceKind,
            ResourceId,
            Metric,
            ProductKey,
            Quantity,
            StartTime,
            EndTime,
            BillingAccount,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "resourceKind" | "resource_kind" => {
                                Ok(GeneratedField::ResourceKind)
                            }
                            "resourceId" | "resource_id" => {
                                Ok(GeneratedField::ResourceId)
                            }
                            "metric" => Ok(GeneratedField::Metric),
                            "productKey" | "product_key" => {
                                Ok(GeneratedField::ProductKey)
                            }
                            "quantity" => Ok(GeneratedField::Quantity),
                            "startTime" | "start_time" => Ok(GeneratedField::StartTime),
                            "endTime" | "end_time" => Ok(GeneratedField::EndTime),
                            "billingAccount" | "billing_account" => {
                                Ok(GeneratedField::BillingAccount)
                            }
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = UsageRecord;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.billing.v1beta1.UsageRecord")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<UsageRecord, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut resource_kind__ = None;
                let mut resource_id__ = None;
                let mut metric__ = None;
                let mut product_key__ = None;
                let mut quantity__ = None;
                let mut start_time__ = None;
                let mut end_time__ = None;
                let mut billing_account__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::ResourceKind => {
                            if resource_kind__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("resourceKind"),
                                );
                            }
                            resource_kind__ = Some(map_.next_value()?);
                        }
                        GeneratedField::ResourceId => {
                            if resource_id__.is_some() {
                                return Err(serde::de::Error::duplicate_field("resourceId"));
                            }
                            resource_id__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Metric => {
                            if metric__.is_some() {
                                return Err(serde::de::Error::duplicate_field("metric"));
                            }
                            metric__ = Some(map_.next_value()?);
                        }
                        GeneratedField::ProductKey => {
                            if product_key__.is_some() {
                                return Err(serde::de::Error::duplicate_field("productKey"));
                            }
                            product_key__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Quantity => {
                            if quantity__.is_some() {
                                return Err(serde::de::Error::duplicate_field("quantity"));
                            }
                            quantity__ = Some(map_.next_value()?);
                        }
                        GeneratedField::StartTime => {
                            if start_time__.is_some() {
                                return Err(serde::de::Error::duplicate_field("startTime"));
                            }
                            start_time__ = map_.next_value()?;
                        }
                        GeneratedField::EndTime => {
                            if end_time__.is_some() {
                                return Err(serde::de::Error::duplicate_field("endTime"));
                            }
                            end_time__ = map_.next_value()?;
                        }
                        GeneratedField::BillingAccount => {
                            if billing_account__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("billingAccount"),
                                );
                            }
                            billing_account__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(UsageRecord {
                    resource_kind: resource_kind__.unwrap_or_default(),
                    resource_id: resource_id__.unwrap_or_default(),
                    metric: metric__.unwrap_or_default(),
                    product_key: product_key__.unwrap_or_default(),
                    quantity: quantity__.unwrap_or_default(),
                    start_time: start_time__,
                    end_time: end_time__,
                    billing_account: billing_account__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.billing.v1beta1.UsageRecord",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
/// Calls `BillingAccountService`.
///
/// Billing accounts, which project each one pays for, and how they are paid.
#[derive(Clone, Debug)]
pub struct BillingAccountClient {
    service: ::origincloud_core::Service,
}
impl BillingAccountClient {
    /// Returns a client of `BillingAccountService` that sends its calls through `client`.
    pub fn new(client: &::origincloud_core::Client) -> Self {
        Self {
            service: client.service("billing", false),
        }
    }
    /// The endpoint the client sends its calls to, which also serves the operations its methods answer with.
    pub fn service(&self) -> &::origincloud_core::Service {
        &self.service
    }
    /// Returns a billing account. Needs `admin.billing_account.get` on the
    /// organization.
    pub async fn get_billing_account(
        &self,
        request: GetBillingAccountRequest,
    ) -> ::core::result::Result<BillingAccount, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "name",
            &request.name,
            "organizations/*/billingAccounts/*",
        )?;
        let query = ::origincloud_core::query(&request, &["name"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::GET,
                format!("/v1beta1/{p0}"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Lists an organization's billing accounts, oldest first. Needs
    /// `admin.billing_account.list` on the organization.
    pub async fn list_billing_accounts(
        &self,
        request: ListBillingAccountsRequest,
    ) -> ::core::result::Result<ListBillingAccountsResponse, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "parent",
            &request.parent,
            "organizations/*",
        )?;
        let query = ::origincloud_core::query(&request, &["parent"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::GET,
                format!("/v1beta1/{p0}/billingAccounts"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Returns everything [`list_billing_accounts`](Self::list_billing_accounts) lists from `request`'s page on, fetching the next page as the stream reaches it. A page that fails ends the stream with its error.
    pub fn all_billing_accounts(
        &self,
        request: ListBillingAccountsRequest,
    ) -> ::origincloud_core::Pages<BillingAccount> {
        let client = self.clone();
        ::origincloud_core::Pages::new(
            request,
            move |request: ListBillingAccountsRequest| {
                let client = client.clone();
                async move {
                    let page = client.list_billing_accounts(request).await?;
                    Ok((page.billing_accounts, page.next_page_token))
                }
            },
            |request: &mut ListBillingAccountsRequest, token: ::std::string::String| {
                request.page_token = token;
            },
        )
    }
    /// Creates a billing account with its profile: `display_name`,
    /// `billing_address`, `invoice_email` and `contact_person` are required,
    /// and `vat_id` too for a billing address outside Germany. The account
    /// has no payment method yet: until one is verified, the projects linked
    /// to it can't create billable resources. Creating it grants nobody a
    /// role: whoever can create billing accounts can use it. Needs
    /// `admin.billing_account.create` on the organization.
    pub async fn create_billing_account(
        &self,
        mut request: CreateBillingAccountRequest,
    ) -> ::core::result::Result<BillingAccount, ::origincloud_core::Error> {
        if request.request_id.is_empty() {
            request.request_id = ::origincloud_core::new_request_id();
        }
        let p0 = ::origincloud_core::path_value(
            "parent",
            &request.parent,
            "organizations/*",
        )?;
        let body = ::origincloud_core::json_body(
            request
                .billing_account
                .as_ref()
                .unwrap_or(&::core::default::Default::default()),
        )?;
        let query = ::origincloud_core::query(&request, &["parent", "billingAccount"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::POST,
                format!("/v1beta1/{p0}/billingAccounts"),
            )
            .with_body(body)
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Changes a billing account's `display_name` or its profile. The profile
    /// fields named in `update_mask` are replaced and the others kept; once
    /// the update is applied, the account must have a whole profile
    /// (`billing_address`, `invoice_email`, `contact_person`, and `vat_id`
    /// for a billing address outside Germany), or the update is refused. Needs
    /// `admin.billing_account.update` on the organization.
    pub async fn update_billing_account(
        &self,
        request: UpdateBillingAccountRequest,
    ) -> ::core::result::Result<BillingAccount, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "billingAccount.name",
            request.billing_account.as_ref().map_or("", |m| m.name.as_str()),
            "organizations/*/billingAccounts/*",
        )?;
        let body = ::origincloud_core::json_body(
            request
                .billing_account
                .as_ref()
                .unwrap_or(&::core::default::Default::default()),
        )?;
        let query = ::origincloud_core::query(
            &request,
            &["billingAccount.name", "billingAccount"],
        )?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::PATCH,
                format!("/v1beta1/{p0}"),
            )
            .with_body(body)
            .with_query(query);
        self.service.call(call).await
    }
    /// Deletes a billing account. Refused as a `CONFLICT` for the
    /// organization's default billing account, while a project is linked to
    /// the account (link it to another account first), and while the account
    /// has a spend limit (remove it first). Needs
    /// `admin.billing_account.delete` on the organization.
    pub async fn delete_billing_account(
        &self,
        request: DeleteBillingAccountRequest,
    ) -> ::core::result::Result<
        ::origincloud_core::protobuf::Empty,
        ::origincloud_core::Error,
    > {
        let p0 = ::origincloud_core::path_value(
            "name",
            &request.name,
            "organizations/*/billingAccounts/*",
        )?;
        let query = ::origincloud_core::query(&request, &["name"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::DELETE,
                format!("/v1beta1/{p0}"),
            )
            .with_query(query);
        self.service.call(call).await
    }
    /// Starts adding a payment method to a billing account, and returns the
    /// payment provider's page to open in a browser: the payment details are
    /// entered there and never pass through this API. Once that page is done,
    /// call ConfirmPaymentMethodSetup. Starting again replaces a setup that
    /// wasn't confirmed. Refused as `INVALID_ARGUMENT` for an account whose
    /// `payment_method.state` is `payment_method::State::NotRequired`. Needs
    /// `admin.billing_account.update` on the organization.
    pub async fn start_payment_method_setup(
        &self,
        request: StartPaymentMethodSetupRequest,
    ) -> ::core::result::Result<
        StartPaymentMethodSetupResponse,
        ::origincloud_core::Error,
    > {
        let p0 = ::origincloud_core::path_value(
            "name",
            &request.name,
            "organizations/*/billingAccounts/*",
        )?;
        let body = ::origincloud_core::json_body(&request)?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::POST,
                format!("/v1beta1/{p0}:startPaymentMethodSetup"),
            )
            .with_body(body);
        self.service.call(call).await
    }
    /// Completes the setup StartPaymentMethodSetup started, once its page is
    /// done: the payment provider is asked whether it finished, and only a
    /// finished setup is recorded. The account's `payment_method` is then
    /// `payment_method::State::Verified`, replacing any earlier one, and its projects can create
    /// billable resources. An unfinished or abandoned setup is refused as
    /// `INVALID_ARGUMENT` and changes nothing: finish the page, or start
    /// again. So is an account with no setup started, which includes a
    /// repeat of a confirmation that succeeded: read the account to see
    /// whether it did. Needs `admin.billing_account.update` on the
    /// organization.
    pub async fn confirm_payment_method_setup(
        &self,
        request: ConfirmPaymentMethodSetupRequest,
    ) -> ::core::result::Result<BillingAccount, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "name",
            &request.name,
            "organizations/*/billingAccounts/*",
        )?;
        let body = ::origincloud_core::json_body(&request)?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::POST,
                format!("/v1beta1/{p0}:confirmPaymentMethodSetup"),
            )
            .with_body(body);
        self.service.call(call).await
    }
    /// Returns which billing account pays for a project. Needs
    /// `admin.project.get` on the project.
    pub async fn get_project_billing_info(
        &self,
        request: GetProjectBillingInfoRequest,
    ) -> ::core::result::Result<ProjectBillingInfo, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "name",
            &request.name,
            "projects/*/billingInfo",
        )?;
        let query = ::origincloud_core::query(&request, &["name"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::GET,
                format!("/v1beta1/{p0}"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Links a project to another billing account of its organization, which
    /// pays for its usage from then on; what it used before stays charged to
    /// the account it was linked to then. A project is always linked to one
    /// account, so there is nothing to unlink. Needs `admin.project.attach`
    /// on the project, which is separate from access to billing accounts.
    pub async fn update_project_billing_info(
        &self,
        request: UpdateProjectBillingInfoRequest,
    ) -> ::core::result::Result<ProjectBillingInfo, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "projectBillingInfo.name",
            request.project_billing_info.as_ref().map_or("", |m| m.name.as_str()),
            "projects/*/billingInfo",
        )?;
        let body = ::origincloud_core::json_body(
            request
                .project_billing_info
                .as_ref()
                .unwrap_or(&::core::default::Default::default()),
        )?;
        let query = ::origincloud_core::query(
            &request,
            &["projectBillingInfo.name", "projectBillingInfo"],
        )?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::PATCH,
                format!("/v1beta1/{p0}"),
            )
            .with_body(body)
            .with_query(query);
        self.service.call(call).await
    }
    /// Lists the projects a billing account pays for, oldest first. Needs
    /// `admin.billing_account.get` on the organization.
    pub async fn list_project_billing_info(
        &self,
        request: ListProjectBillingInfoRequest,
    ) -> ::core::result::Result<
        ListProjectBillingInfoResponse,
        ::origincloud_core::Error,
    > {
        let p0 = ::origincloud_core::path_value(
            "name",
            &request.name,
            "organizations/*/billingAccounts/*",
        )?;
        let query = ::origincloud_core::query(&request, &["name"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::GET,
                format!("/v1beta1/{p0}/projects"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Returns everything [`list_project_billing_info`](Self::list_project_billing_info) lists from `request`'s page on, fetching the next page as the stream reaches it. A page that fails ends the stream with its error.
    pub fn all_project_billing_infos(
        &self,
        request: ListProjectBillingInfoRequest,
    ) -> ::origincloud_core::Pages<ProjectBillingInfo> {
        let client = self.clone();
        ::origincloud_core::Pages::new(
            request,
            move |request: ListProjectBillingInfoRequest| {
                let client = client.clone();
                async move {
                    let page = client.list_project_billing_info(request).await?;
                    Ok((page.project_billing_infos, page.next_page_token))
                }
            },
            |request: &mut ListProjectBillingInfoRequest, token: ::std::string::String| {
                request.page_token = token;
            },
        )
    }
    /// Returns a country a billing address may be in.
    pub async fn get_billing_country(
        &self,
        request: GetBillingCountryRequest,
    ) -> ::core::result::Result<BillingCountry, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "name",
            &request.name,
            "billingCountries/*",
        )?;
        let query = ::origincloud_core::query(&request, &["name"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::GET,
                format!("/v1beta1/{p0}"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Lists the countries a billing address may be in, in the order a form
    /// shows them, and whether each needs a VAT id.
    pub async fn list_billing_countries(
        &self,
        request: ListBillingCountriesRequest,
    ) -> ::core::result::Result<
        ListBillingCountriesResponse,
        ::origincloud_core::Error,
    > {
        let query = ::origincloud_core::query(&request, &[])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::GET,
                ::std::string::String::from("/v1beta1/billingCountries"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Returns everything [`list_billing_countries`](Self::list_billing_countries) lists from `request`'s page on, fetching the next page as the stream reaches it. A page that fails ends the stream with its error.
    pub fn all_billing_countries(
        &self,
        request: ListBillingCountriesRequest,
    ) -> ::origincloud_core::Pages<BillingCountry> {
        let client = self.clone();
        ::origincloud_core::Pages::new(
            request,
            move |request: ListBillingCountriesRequest| {
                let client = client.clone();
                async move {
                    let page = client.list_billing_countries(request).await?;
                    Ok((page.billing_countries, page.next_page_token))
                }
            },
            |request: &mut ListBillingCountriesRequest, token: ::std::string::String| {
                request.page_token = token;
            },
        )
    }
}
/// Calls `CostService`.
///
/// Usage and cost: what a project, an organization or a billing account used
/// in a period, and what it costs, as read-only reports.
///
/// Usage is metered per resource and priced when it is recorded, at the
/// price list's rate then, so a later price change never changes a past
/// cost. A running resource's usage is recorded at least hourly; the last
/// hour can still be missing from a report.
#[derive(Clone, Debug)]
pub struct CostClient {
    service: ::origincloud_core::Service,
}
impl CostClient {
    /// Returns a client of `CostService` that sends its calls through `client`.
    pub fn new(client: &::origincloud_core::Client) -> Self {
        Self {
            service: client.service("billing", false),
        }
    }
    /// The endpoint the client sends its calls to, which also serves the operations its methods answer with.
    pub fn service(&self) -> &::origincloud_core::Service {
        &self.service
    }
    /// Returns a project's cost in a period, by service and product, in hourly
    /// or daily buckets. Needs `admin.usage.list` on the organization.
    pub async fn query_project_cost(
        &self,
        request: QueryProjectCostRequest,
    ) -> ::core::result::Result<CostReport, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "project",
            &request.project,
            "projects/*",
        )?;
        let query = ::origincloud_core::query(&request, &["project"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::GET,
                format!("/v1beta1/{p0}:queryCost"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Returns an organization's cost in a period: every project's together,
    /// by service and product, and each project's on its own. Needs
    /// `admin.usage.list` on the organization, which reads every project's
    /// cost in it.
    pub async fn query_organization_cost(
        &self,
        request: QueryOrganizationCostRequest,
    ) -> ::core::result::Result<OrganizationCostReport, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "organization",
            &request.organization,
            "organizations/*",
        )?;
        let query = ::origincloud_core::query(&request, &["organization"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::GET,
                format!("/v1beta1/{p0}:queryCost"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Returns what was charged to a billing account in a period, by service
    /// and product. A project's cost is charged to the account it was linked
    /// to when the usage was recorded, so moving a project moves only its
    /// later cost. Its spend limit compares the calendar month's total with
    /// `limit`. Needs `admin.spend_limit.get` on the organization.
    pub async fn query_billing_account_cost(
        &self,
        request: QueryBillingAccountCostRequest,
    ) -> ::core::result::Result<CostReport, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "billingAccount",
            &request.billing_account,
            "organizations/*/billingAccounts/*",
        )?;
        let query = ::origincloud_core::query(&request, &["billingAccount"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::GET,
                format!("/v1beta1/{p0}:queryCost"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Lists a project's metered usage records that overlap a period, the
    /// input its cost is priced from, oldest first. Needs `admin.usage.list`
    /// on the organization.
    pub async fn query_project_usage(
        &self,
        request: QueryProjectUsageRequest,
    ) -> ::core::result::Result<QueryProjectUsageResponse, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "project",
            &request.project,
            "projects/*",
        )?;
        let query = ::origincloud_core::query(&request, &["project"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::GET,
                format!("/v1beta1/{p0}:queryUsage"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Returns everything [`query_project_usage`](Self::query_project_usage) lists from `request`'s page on, fetching the next page as the stream reaches it. A page that fails ends the stream with its error.
    pub fn all_usage_records(
        &self,
        request: QueryProjectUsageRequest,
    ) -> ::origincloud_core::Pages<UsageRecord> {
        let client = self.clone();
        ::origincloud_core::Pages::new(
            request,
            move |request: QueryProjectUsageRequest| {
                let client = client.clone();
                async move {
                    let page = client.query_project_usage(request).await?;
                    Ok((page.usage_records, page.next_page_token))
                }
            },
            |request: &mut QueryProjectUsageRequest, token: ::std::string::String| {
                request.page_token = token;
            },
        )
    }
}
/// Calls `PriceListService`.
///
/// The public price list: the list price of every billable product, for
/// anyone to read, websites included. It needs no access token.
///
/// Unlike the rest of this API, its path has been `/v1/pricing` since before
/// the API was published, and its fields are written in snake case, as
/// websites read them.
#[derive(Clone, Debug)]
pub struct PriceListClient {
    service: ::origincloud_core::Service,
}
impl PriceListClient {
    /// Returns a client of `PriceListService` that sends its calls through `client`.
    pub fn new(client: &::origincloud_core::Client) -> Self {
        Self {
            service: client.service("billing", false),
        }
    }
    /// The endpoint the client sends its calls to, which also serves the operations its methods answer with.
    pub fn service(&self) -> &::origincloud_core::Service {
        &self.service
    }
    /// Returns the prices in effect now. The answer carries an `ETag`; a
    /// request that sends it back in `If-None-Match` is answered
    /// `304 Not Modified`, without a body, while the list is unchanged.
    pub async fn get_price_list(
        &self,
        request: GetPriceListRequest,
    ) -> ::core::result::Result<PriceList, ::origincloud_core::Error> {
        let query = ::origincloud_core::query(&request, &[])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::GET,
                ::std::string::String::from("/v1/pricing"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
}
/// Calls `SpendLimitService`.
///
/// Spend limits: an amount per calendar month for a billing account, and the
/// shares of it at which an alert is emailed. A spend limit only alerts: it
/// never stops or refuses anything.
///
/// Access to spend limits is granted apart from access to billing accounts:
/// an organization's owner holds it by default.
#[derive(Clone, Debug)]
pub struct SpendLimitClient {
    service: ::origincloud_core::Service,
}
impl SpendLimitClient {
    /// Returns a client of `SpendLimitService` that sends its calls through `client`.
    pub fn new(client: &::origincloud_core::Client) -> Self {
        Self {
            service: client.service("billing", false),
        }
    }
    /// The endpoint the client sends its calls to, which also serves the operations its methods answer with.
    pub fn service(&self) -> &::origincloud_core::Service {
        &self.service
    }
    /// Returns a billing account's spend limit; one that has none has no
    /// `limit`. Needs `admin.spend_limit.get` on the organization.
    pub async fn get_spend_limit(
        &self,
        request: GetSpendLimitRequest,
    ) -> ::core::result::Result<SpendLimit, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "name",
            &request.name,
            "organizations/*/billingAccounts/*/spendLimit",
        )?;
        let query = ::origincloud_core::query(&request, &["name"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::GET,
                format!("/v1beta1/{p0}"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Sets or removes a billing account's spend limit. The fields named in
    /// `update_mask` are replaced and the others kept. A spend limit left
    /// without a `limit` is removed, with its thresholds and recipients. Needs
    /// `admin.spend_limit.update` on the organization.
    pub async fn update_spend_limit(
        &self,
        request: UpdateSpendLimitRequest,
    ) -> ::core::result::Result<SpendLimit, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "spendLimit.name",
            request.spend_limit.as_ref().map_or("", |m| m.name.as_str()),
            "organizations/*/billingAccounts/*/spendLimit",
        )?;
        let body = ::origincloud_core::json_body(
            request.spend_limit.as_ref().unwrap_or(&::core::default::Default::default()),
        )?;
        let query = ::origincloud_core::query(
            &request,
            &["spendLimit.name", "spendLimit"],
        )?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::PATCH,
                format!("/v1beta1/{p0}"),
            )
            .with_body(body)
            .with_query(query);
        self.service.call(call).await
    }
}