origincloud_resourcemanager/generated/

origincloud.resourcemanager.v1beta1.rs

// Code generated by origincloud-sdk-generator. DO NOT EDIT.
// source: origincloud/resourcemanager/v1beta1/quota.proto
// source: origincloud/resourcemanager/v1beta1/organization.proto
// source: origincloud/resourcemanager/v1beta1/project.proto

/// An organization's quota: the most of each kind of resource its projects
/// may hold together, and how much of it they use. Creating a resource past a
/// limit is refused.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct OrganizationQuota {
    /// The quota's resource name, `organizations/{organization}/quota`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The most instances that aren't terminated.
    #[prost(int64, tag = "2")]
    pub max_instances: i64,
    /// The most vCPUs, summed over the instances that aren't terminated.
    #[prost(int64, tag = "3")]
    pub max_vcpu: i64,
    /// The most GiB of volumes that aren't deleted.
    #[prost(int64, tag = "4")]
    pub max_volume_gib: i64,
    /// The most VPCs.
    #[prost(int64, tag = "5")]
    pub max_vpcs: i64,
    /// The most floating IPs.
    #[prost(int64, tag = "6")]
    pub max_public_ips: i64,
    /// The most DNS hosted zones, including those not yet verified.
    #[prost(int64, tag = "8")]
    pub max_hosted_zones: i64,
    /// The most DNS record sets, summed over every hosted zone.
    #[prost(int64, tag = "9")]
    pub max_record_sets: i64,
    /// How much of each limit the organization's projects use together.
    #[prost(message, optional, tag = "7")]
    pub usage: ::core::option::Option<QuotaUsage>,
}
/// A project's quota: the budgets its owners set for it, and how much of each
/// the project uses. A project without a budget for a kind of resource is
/// bounded by its organization's quota alone; with one, by both. Budgets are
/// not reservations: several projects' budgets may add up to more than the
/// organization's limit.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ProjectQuota {
    /// The quota's resource name, `projects/{project}/quota`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The most instances that aren't terminated; unset means no budget. Each
    /// budget is zero or more, and no more than the organization's limit for
    /// the same kind.
    #[prost(int64, optional, tag = "2")]
    pub max_instances: ::core::option::Option<i64>,
    /// The most vCPUs, summed over the instances that aren't terminated; unset
    /// means no budget.
    #[prost(int64, optional, tag = "3")]
    pub max_vcpu: ::core::option::Option<i64>,
    /// The most GiB of volumes that aren't deleted; unset means no budget.
    #[prost(int64, optional, tag = "4")]
    pub max_volume_gib: ::core::option::Option<i64>,
    /// The most VPCs; unset means no budget.
    #[prost(int64, optional, tag = "5")]
    pub max_vpcs: ::core::option::Option<i64>,
    /// The most floating IPs; unset means no budget.
    #[prost(int64, optional, tag = "6")]
    pub max_public_ips: ::core::option::Option<i64>,
    /// The most DNS hosted zones, including those not yet verified; unset
    /// means no budget.
    #[prost(int64, optional, tag = "8")]
    pub max_hosted_zones: ::core::option::Option<i64>,
    /// The most DNS record sets, summed over the project's hosted zones; unset
    /// means no budget.
    #[prost(int64, optional, tag = "9")]
    pub max_record_sets: ::core::option::Option<i64>,
    /// How much of each budget the project uses.
    #[prost(message, optional, tag = "7")]
    pub usage: ::core::option::Option<QuotaUsage>,
}
/// How many of each kind of resource are held. Counted continuously, so a
/// resource just created or deleted can take up to half a minute to show;
/// a limit is enforced on the exact count.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct QuotaUsage {
    /// Instances that aren't terminated.
    #[prost(int64, tag = "1")]
    pub instances: i64,
    /// vCPUs of the instances that aren't terminated.
    #[prost(int64, tag = "2")]
    pub vcpu: i64,
    /// GiB of volumes that aren't deleted.
    #[prost(int64, tag = "3")]
    pub volume_gib: i64,
    /// VPCs.
    #[prost(int64, tag = "4")]
    pub vpcs: i64,
    /// Floating IPs.
    #[prost(int64, tag = "5")]
    pub public_ips: i64,
    /// DNS hosted zones, including those not yet verified; unset while they
    /// can't be counted, the other figures answered all the same.
    #[prost(int64, optional, tag = "6")]
    pub hosted_zones: ::core::option::Option<i64>,
    /// DNS record sets; unset while they can't be counted, the other figures
    /// answered all the same.
    #[prost(int64, optional, tag = "7")]
    pub record_sets: ::core::option::Option<i64>,
}
/// An organization: the account its projects, members and billing belong to.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Organization {
    /// The organization's resource name, `organizations/{organization}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The organization'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 shows, typically the company's name. Not empty.
    #[prost(string, tag = "3")]
    pub display_name: ::prost::alloc::string::String,
    /// Whether the organization may create resources. Decided by the
    /// platform, never by the organization's members.
    #[prost(enumeration = "organization::State", tag = "4")]
    pub state: i32,
    /// When the organization was created.
    #[prost(message, optional, tag = "5")]
    pub create_time: ::core::option::Option<::origincloud_core::protobuf::Timestamp>,
    /// The principal that created the organization, such as `user:<id>` or
    /// `service_account:<id>`.
    #[prost(string, tag = "6")]
    pub creator: ::prost::alloc::string::String,
}
/// Nested message and enum types in `Organization`.
pub mod organization {
    /// Whether the organization may create resources.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        /// Not set.
        Unspecified = 0,
        /// Under review by the platform: it can't create projects or resources
        /// until it is `organization::State::Active`.
        PendingReview = 1,
        /// Admitted: it can create projects and resources.
        Active = 2,
        /// Not admitted. Final.
        Rejected = 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::PendingReview => "PENDING_REVIEW",
                Self::Active => "ACTIVE",
                Self::Rejected => "REJECTED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATE_UNSPECIFIED" => Some(Self::Unspecified),
                "PENDING_REVIEW" => Some(Self::PendingReview),
                "ACTIVE" => Some(Self::Active),
                "REJECTED" => Some(Self::Rejected),
                _ => None,
            }
        }
    }
}
/// The request for GetOrganization.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetOrganizationRequest {
    /// The organization to return.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request for ListOrganizations.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListOrganizationsRequest {
    /// The most organizations 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 ListOrganizations.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListOrganizationsResponse {
    /// The organizations on this page.
    #[prost(message, repeated, tag = "1")]
    pub organizations: ::prost::alloc::vec::Vec<Organization>,
    /// 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 CreateOrganization.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreateOrganizationRequest {
    /// The organization to create: its `display_name`.
    #[prost(message, optional, tag = "1")]
    pub organization: ::core::option::Option<Organization>,
    /// A UUID; a repeat with the same id returns the organization the first
    /// request created instead of creating a second one.
    #[prost(string, tag = "2")]
    pub request_id: ::prost::alloc::string::String,
}
/// The request for UpdateOrganization.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UpdateOrganizationRequest {
    /// The organization, by its name, with the fields to change.
    #[prost(message, optional, tag = "1")]
    pub organization: ::core::option::Option<Organization>,
    /// The fields to change: `display_name`. `*` is the same.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::origincloud_core::protobuf::FieldMask>,
}
/// The request for DeleteOrganization.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteOrganizationRequest {
    /// The organization to delete.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request for GetOrganizationQuota.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetOrganizationQuotaRequest {
    /// The quota to return, `organizations/{organization}/quota`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// A project: the namespace an organization's resources are created in.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Project {
    /// The project's resource name, `projects/{project}`. The id, chosen when
    /// the project is created, is unique across the platform and never used
    /// again, not even after the project is deleted.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The project's URN, the identifier access policies and the audit log
    /// use.
    #[prost(string, tag = "2")]
    pub urn: ::prost::alloc::string::String,
    /// The organization the project belongs to, `organizations/{organization}`.
    #[prost(string, tag = "3")]
    pub organization: ::prost::alloc::string::String,
    /// The name the console shows. Not empty.
    #[prost(string, tag = "4")]
    pub display_name: ::prost::alloc::string::String,
    /// When the project was created.
    #[prost(message, optional, tag = "5")]
    pub create_time: ::core::option::Option<::origincloud_core::protobuf::Timestamp>,
    /// The principal that created the project, such as `user:<id>` or
    /// `service_account:<id>`.
    #[prost(string, tag = "6")]
    pub creator: ::prost::alloc::string::String,
}
/// The request for GetProject.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetProjectRequest {
    /// The project to return.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request for ListProjects.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListProjectsRequest {
    /// The organization whose projects to list, `organizations/{organization}`.
    #[prost(string, tag = "1")]
    pub organization: ::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 ListProjects.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListProjectsResponse {
    /// The projects on this page.
    #[prost(message, repeated, tag = "1")]
    pub projects: ::prost::alloc::vec::Vec<Project>,
    /// 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 CreateProject.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreateProjectRequest {
    /// The project to create: its `organization` and `display_name`.
    #[prost(message, optional, tag = "1")]
    pub project: ::core::option::Option<Project>,
    /// The project's id, the last segment of its name: 6 to 16 lowercase
    /// letters, digits and hyphens, starting with a letter and not ending with
    /// a hyphen, such as `acme-prod`.
    #[prost(string, tag = "3")]
    pub project_id: ::prost::alloc::string::String,
    /// A UUID; a repeat with the same id returns the project the first request
    /// created instead of creating a second one.
    #[prost(string, tag = "2")]
    pub request_id: ::prost::alloc::string::String,
}
/// The request for UpdateProject.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UpdateProjectRequest {
    /// The project, by its name, with the fields to change.
    #[prost(message, optional, tag = "1")]
    pub project: ::core::option::Option<Project>,
    /// The fields to change: `display_name`. `*` is the same.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::origincloud_core::protobuf::FieldMask>,
}
/// The request for DeleteProject.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteProjectRequest {
    /// The project to delete.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request for GetProjectQuota.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetProjectQuotaRequest {
    /// The quota to return, `projects/{project}/quota`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request for UpdateProjectQuota.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UpdateProjectQuotaRequest {
    /// The quota, by its name, with the budgets to set.
    #[prost(message, optional, tag = "1")]
    pub project_quota: ::core::option::Option<ProjectQuota>,
    /// The budgets to set or remove, such as `max_vcpu`. `*` is every budget:
    /// those given are set, the others removed.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::origincloud_core::protobuf::FieldMask>,
}
impl serde::Serialize for CreateOrganizationRequest {
    #[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_some() {
            len += 1;
        }
        if !self.request_id.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.resourcemanager.v1beta1.CreateOrganizationRequest",
                len,
            )?;
        if let Some(v) = self.organization.as_ref() {
            struct_ser.serialize_field("organization", v)?;
        }
        if !self.request_id.is_empty() {
            struct_ser.serialize_field("requestId", &self.request_id)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for CreateOrganizationRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["organization", "request_id", "requestId"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Organization,
            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 {
                            "organization" => Ok(GeneratedField::Organization),
                            "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 = CreateOrganizationRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.resourcemanager.v1beta1.CreateOrganizationRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<CreateOrganizationRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut organization__ = None;
                let mut request_id__ = 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__ = 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(CreateOrganizationRequest {
                    organization: organization__,
                    request_id: request_id__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.resourcemanager.v1beta1.CreateOrganizationRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for CreateProjectRequest {
    #[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_some() {
            len += 1;
        }
        if !self.project_id.is_empty() {
            len += 1;
        }
        if !self.request_id.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.resourcemanager.v1beta1.CreateProjectRequest",
                len,
            )?;
        if let Some(v) = self.project.as_ref() {
            struct_ser.serialize_field("project", v)?;
        }
        if !self.project_id.is_empty() {
            struct_ser.serialize_field("projectId", &self.project_id)?;
        }
        if !self.request_id.is_empty() {
            struct_ser.serialize_field("requestId", &self.request_id)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for CreateProjectRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "project",
            "project_id",
            "projectId",
            "request_id",
            "requestId",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Project,
            ProjectId,
            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 {
                            "project" => Ok(GeneratedField::Project),
                            "projectId" | "project_id" => Ok(GeneratedField::ProjectId),
                            "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 = CreateProjectRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.resourcemanager.v1beta1.CreateProjectRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<CreateProjectRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut project__ = None;
                let mut project_id__ = None;
                let mut request_id__ = 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__ = map_.next_value()?;
                        }
                        GeneratedField::ProjectId => {
                            if project_id__.is_some() {
                                return Err(serde::de::Error::duplicate_field("projectId"));
                            }
                            project_id__ = Some(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(CreateProjectRequest {
                    project: project__,
                    project_id: project_id__.unwrap_or_default(),
                    request_id: request_id__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.resourcemanager.v1beta1.CreateProjectRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for DeleteOrganizationRequest {
    #[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.resourcemanager.v1beta1.DeleteOrganizationRequest",
                len,
            )?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for DeleteOrganizationRequest {
    #[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 = DeleteOrganizationRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.resourcemanager.v1beta1.DeleteOrganizationRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<DeleteOrganizationRequest, 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(DeleteOrganizationRequest {
                    name: name__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.resourcemanager.v1beta1.DeleteOrganizationRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for DeleteProjectRequest {
    #[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.resourcemanager.v1beta1.DeleteProjectRequest",
                len,
            )?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for DeleteProjectRequest {
    #[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 = DeleteProjectRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.resourcemanager.v1beta1.DeleteProjectRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<DeleteProjectRequest, 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(DeleteProjectRequest {
                    name: name__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.resourcemanager.v1beta1.DeleteProjectRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for GetOrganizationQuotaRequest {
    #[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.resourcemanager.v1beta1.GetOrganizationQuotaRequest",
                len,
            )?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for GetOrganizationQuotaRequest {
    #[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 = GetOrganizationQuotaRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.resourcemanager.v1beta1.GetOrganizationQuotaRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<GetOrganizationQuotaRequest, 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(GetOrganizationQuotaRequest {
                    name: name__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.resourcemanager.v1beta1.GetOrganizationQuotaRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for GetOrganizationRequest {
    #[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.resourcemanager.v1beta1.GetOrganizationRequest",
                len,
            )?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for GetOrganizationRequest {
    #[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 = GetOrganizationRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.resourcemanager.v1beta1.GetOrganizationRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<GetOrganizationRequest, 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(GetOrganizationRequest {
                    name: name__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.resourcemanager.v1beta1.GetOrganizationRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for GetProjectQuotaRequest {
    #[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.resourcemanager.v1beta1.GetProjectQuotaRequest",
                len,
            )?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for GetProjectQuotaRequest {
    #[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 = GetProjectQuotaRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.resourcemanager.v1beta1.GetProjectQuotaRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<GetProjectQuotaRequest, 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(GetProjectQuotaRequest {
                    name: name__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.resourcemanager.v1beta1.GetProjectQuotaRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for GetProjectRequest {
    #[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.resourcemanager.v1beta1.GetProjectRequest",
                len,
            )?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for GetProjectRequest {
    #[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 = GetProjectRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.resourcemanager.v1beta1.GetProjectRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<GetProjectRequest, 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(GetProjectRequest {
                    name: name__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.resourcemanager.v1beta1.GetProjectRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListOrganizationsRequest {
    #[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.resourcemanager.v1beta1.ListOrganizationsRequest",
                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 ListOrganizationsRequest {
    #[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 = ListOrganizationsRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.resourcemanager.v1beta1.ListOrganizationsRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListOrganizationsRequest, 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(ListOrganizationsRequest {
                    page_size: page_size__.unwrap_or_default(),
                    page_token: page_token__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.resourcemanager.v1beta1.ListOrganizationsRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListOrganizationsResponse {
    #[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.organizations.is_empty() {
            len += 1;
        }
        if !self.next_page_token.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.resourcemanager.v1beta1.ListOrganizationsResponse",
                len,
            )?;
        if !self.organizations.is_empty() {
            struct_ser.serialize_field("organizations", &self.organizations)?;
        }
        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 ListOrganizationsResponse {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["organizations", "next_page_token", "nextPageToken"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Organizations,
            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 {
                            "organizations" => Ok(GeneratedField::Organizations),
                            "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 = ListOrganizationsResponse;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.resourcemanager.v1beta1.ListOrganizationsResponse",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListOrganizationsResponse, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut organizations__ = None;
                let mut next_page_token__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Organizations => {
                            if organizations__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("organizations"),
                                );
                            }
                            organizations__ = 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(ListOrganizationsResponse {
                    organizations: organizations__.unwrap_or_default(),
                    next_page_token: next_page_token__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.resourcemanager.v1beta1.ListOrganizationsResponse",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListProjectsRequest {
    #[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.page_size != 0 {
            len += 1;
        }
        if !self.page_token.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.resourcemanager.v1beta1.ListProjectsRequest",
                len,
            )?;
        if !self.organization.is_empty() {
            struct_ser.serialize_field("organization", &self.organization)?;
        }
        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 ListProjectsRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "organization",
            "page_size",
            "pageSize",
            "page_token",
            "pageToken",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Organization,
            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 {
                            "organization" => Ok(GeneratedField::Organization),
                            "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 = ListProjectsRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.resourcemanager.v1beta1.ListProjectsRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListProjectsRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut organization__ = None;
                let mut page_size__ = None;
                let mut page_token__ = 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::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(ListProjectsRequest {
                    organization: organization__.unwrap_or_default(),
                    page_size: page_size__.unwrap_or_default(),
                    page_token: page_token__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.resourcemanager.v1beta1.ListProjectsRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListProjectsResponse {
    #[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.projects.is_empty() {
            len += 1;
        }
        if !self.next_page_token.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.resourcemanager.v1beta1.ListProjectsResponse",
                len,
            )?;
        if !self.projects.is_empty() {
            struct_ser.serialize_field("projects", &self.projects)?;
        }
        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 ListProjectsResponse {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["projects", "next_page_token", "nextPageToken"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Projects,
            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 {
                            "projects" => Ok(GeneratedField::Projects),
                            "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 = ListProjectsResponse;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.resourcemanager.v1beta1.ListProjectsResponse",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListProjectsResponse, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut projects__ = None;
                let mut next_page_token__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Projects => {
                            if projects__.is_some() {
                                return Err(serde::de::Error::duplicate_field("projects"));
                            }
                            projects__ = 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(ListProjectsResponse {
                    projects: projects__.unwrap_or_default(),
                    next_page_token: next_page_token__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.resourcemanager.v1beta1.ListProjectsResponse",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for Organization {
    #[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.state != 0 {
            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.resourcemanager.v1beta1.Organization", 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.state != 0 {
            let v = organization::State::try_from(self.state)
                .map_err(|_| serde::ser::Error::custom(
                    format!("Invalid variant {}", self.state),
                ))?;
            struct_ser.serialize_field("state", &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 Organization {
    #[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",
            "state",
            "create_time",
            "createTime",
            "creator",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            Urn,
            DisplayName,
            State,
            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)
                            }
                            "state" => Ok(GeneratedField::State),
                            "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 = Organization;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.resourcemanager.v1beta1.Organization")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<Organization, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                let mut urn__ = None;
                let mut display_name__ = None;
                let mut state__ = 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::State => {
                            if state__.is_some() {
                                return Err(serde::de::Error::duplicate_field("state"));
                            }
                            state__ = Some(
                                map_.next_value::<organization::State>()? as i32,
                            );
                        }
                        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(Organization {
                    name: name__.unwrap_or_default(),
                    urn: urn__.unwrap_or_default(),
                    display_name: display_name__.unwrap_or_default(),
                    state: state__.unwrap_or_default(),
                    create_time: create_time__,
                    creator: creator__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.resourcemanager.v1beta1.Organization",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for organization::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::PendingReview => "PENDING_REVIEW",
            Self::Active => "ACTIVE",
            Self::Rejected => "REJECTED",
        };
        serializer.serialize_str(variant)
    }
}
impl<'de> serde::Deserialize<'de> for organization::State {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "STATE_UNSPECIFIED",
            "PENDING_REVIEW",
            "ACTIVE",
            "REJECTED",
        ];
        struct GeneratedVisitor;
        impl serde::de::Visitor<'_> for GeneratedVisitor {
            type Value = organization::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(organization::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(organization::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(organization::State::Unspecified),
                    "PENDING_REVIEW" => Ok(organization::State::PendingReview),
                    "ACTIVE" => Ok(organization::State::Active),
                    "REJECTED" => Ok(organization::State::Rejected),
                    _ => Ok(organization::State::default()),
                }
            }
        }
        deserializer.deserialize_any(GeneratedVisitor)
    }
}
impl serde::Serialize for OrganizationQuota {
    #[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.max_instances != 0 {
            len += 1;
        }
        if self.max_vcpu != 0 {
            len += 1;
        }
        if self.max_volume_gib != 0 {
            len += 1;
        }
        if self.max_vpcs != 0 {
            len += 1;
        }
        if self.max_public_ips != 0 {
            len += 1;
        }
        if self.max_hosted_zones != 0 {
            len += 1;
        }
        if self.max_record_sets != 0 {
            len += 1;
        }
        if self.usage.is_some() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.resourcemanager.v1beta1.OrganizationQuota",
                len,
            )?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        if self.max_instances != 0 {
            #[allow(clippy::needless_borrow)]
            #[allow(clippy::needless_borrows_for_generic_args)]
            struct_ser
                .serialize_field(
                    "maxInstances",
                    ToString::to_string(&self.max_instances).as_str(),
                )?;
        }
        if self.max_vcpu != 0 {
            #[allow(clippy::needless_borrow)]
            #[allow(clippy::needless_borrows_for_generic_args)]
            struct_ser
                .serialize_field(
                    "maxVcpu",
                    ToString::to_string(&self.max_vcpu).as_str(),
                )?;
        }
        if self.max_volume_gib != 0 {
            #[allow(clippy::needless_borrow)]
            #[allow(clippy::needless_borrows_for_generic_args)]
            struct_ser
                .serialize_field(
                    "maxVolumeGib",
                    ToString::to_string(&self.max_volume_gib).as_str(),
                )?;
        }
        if self.max_vpcs != 0 {
            #[allow(clippy::needless_borrow)]
            #[allow(clippy::needless_borrows_for_generic_args)]
            struct_ser
                .serialize_field(
                    "maxVpcs",
                    ToString::to_string(&self.max_vpcs).as_str(),
                )?;
        }
        if self.max_public_ips != 0 {
            #[allow(clippy::needless_borrow)]
            #[allow(clippy::needless_borrows_for_generic_args)]
            struct_ser
                .serialize_field(
                    "maxPublicIps",
                    ToString::to_string(&self.max_public_ips).as_str(),
                )?;
        }
        if self.max_hosted_zones != 0 {
            #[allow(clippy::needless_borrow)]
            #[allow(clippy::needless_borrows_for_generic_args)]
            struct_ser
                .serialize_field(
                    "maxHostedZones",
                    ToString::to_string(&self.max_hosted_zones).as_str(),
                )?;
        }
        if self.max_record_sets != 0 {
            #[allow(clippy::needless_borrow)]
            #[allow(clippy::needless_borrows_for_generic_args)]
            struct_ser
                .serialize_field(
                    "maxRecordSets",
                    ToString::to_string(&self.max_record_sets).as_str(),
                )?;
        }
        if let Some(v) = self.usage.as_ref() {
            struct_ser.serialize_field("usage", v)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for OrganizationQuota {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "name",
            "max_instances",
            "maxInstances",
            "max_vcpu",
            "maxVcpu",
            "max_volume_gib",
            "maxVolumeGib",
            "max_vpcs",
            "maxVpcs",
            "max_public_ips",
            "maxPublicIps",
            "max_hosted_zones",
            "maxHostedZones",
            "max_record_sets",
            "maxRecordSets",
            "usage",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            MaxInstances,
            MaxVcpu,
            MaxVolumeGib,
            MaxVpcs,
            MaxPublicIps,
            MaxHostedZones,
            MaxRecordSets,
            Usage,
            __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),
                            "maxInstances" | "max_instances" => {
                                Ok(GeneratedField::MaxInstances)
                            }
                            "maxVcpu" | "max_vcpu" => Ok(GeneratedField::MaxVcpu),
                            "maxVolumeGib" | "max_volume_gib" => {
                                Ok(GeneratedField::MaxVolumeGib)
                            }
                            "maxVpcs" | "max_vpcs" => Ok(GeneratedField::MaxVpcs),
                            "maxPublicIps" | "max_public_ips" => {
                                Ok(GeneratedField::MaxPublicIps)
                            }
                            "maxHostedZones" | "max_hosted_zones" => {
                                Ok(GeneratedField::MaxHostedZones)
                            }
                            "maxRecordSets" | "max_record_sets" => {
                                Ok(GeneratedField::MaxRecordSets)
                            }
                            "usage" => Ok(GeneratedField::Usage),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = OrganizationQuota;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.resourcemanager.v1beta1.OrganizationQuota",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<OrganizationQuota, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                let mut max_instances__ = None;
                let mut max_vcpu__ = None;
                let mut max_volume_gib__ = None;
                let mut max_vpcs__ = None;
                let mut max_public_ips__ = None;
                let mut max_hosted_zones__ = None;
                let mut max_record_sets__ = None;
                let mut usage__ = 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::MaxInstances => {
                            if max_instances__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("maxInstances"),
                                );
                            }
                            max_instances__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::MaxVcpu => {
                            if max_vcpu__.is_some() {
                                return Err(serde::de::Error::duplicate_field("maxVcpu"));
                            }
                            max_vcpu__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::MaxVolumeGib => {
                            if max_volume_gib__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("maxVolumeGib"),
                                );
                            }
                            max_volume_gib__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::MaxVpcs => {
                            if max_vpcs__.is_some() {
                                return Err(serde::de::Error::duplicate_field("maxVpcs"));
                            }
                            max_vpcs__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::MaxPublicIps => {
                            if max_public_ips__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("maxPublicIps"),
                                );
                            }
                            max_public_ips__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::MaxHostedZones => {
                            if max_hosted_zones__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("maxHostedZones"),
                                );
                            }
                            max_hosted_zones__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::MaxRecordSets => {
                            if max_record_sets__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("maxRecordSets"),
                                );
                            }
                            max_record_sets__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::Usage => {
                            if usage__.is_some() {
                                return Err(serde::de::Error::duplicate_field("usage"));
                            }
                            usage__ = map_.next_value()?;
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(OrganizationQuota {
                    name: name__.unwrap_or_default(),
                    max_instances: max_instances__.unwrap_or_default(),
                    max_vcpu: max_vcpu__.unwrap_or_default(),
                    max_volume_gib: max_volume_gib__.unwrap_or_default(),
                    max_vpcs: max_vpcs__.unwrap_or_default(),
                    max_public_ips: max_public_ips__.unwrap_or_default(),
                    max_hosted_zones: max_hosted_zones__.unwrap_or_default(),
                    max_record_sets: max_record_sets__.unwrap_or_default(),
                    usage: usage__,
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.resourcemanager.v1beta1.OrganizationQuota",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for Project {
    #[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.organization.is_empty() {
            len += 1;
        }
        if !self.display_name.is_empty() {
            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.resourcemanager.v1beta1.Project", 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.organization.is_empty() {
            struct_ser.serialize_field("organization", &self.organization)?;
        }
        if !self.display_name.is_empty() {
            struct_ser.serialize_field("displayName", &self.display_name)?;
        }
        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 Project {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "name",
            "urn",
            "organization",
            "display_name",
            "displayName",
            "create_time",
            "createTime",
            "creator",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            Urn,
            Organization,
            DisplayName,
            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),
                            "organization" => Ok(GeneratedField::Organization),
                            "displayName" | "display_name" => {
                                Ok(GeneratedField::DisplayName)
                            }
                            "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 = Project;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.resourcemanager.v1beta1.Project")
            }
            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Project, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                let mut urn__ = None;
                let mut organization__ = None;
                let mut display_name__ = 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::Organization => {
                            if organization__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("organization"),
                                );
                            }
                            organization__ = 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::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(Project {
                    name: name__.unwrap_or_default(),
                    urn: urn__.unwrap_or_default(),
                    organization: organization__.unwrap_or_default(),
                    display_name: display_name__.unwrap_or_default(),
                    create_time: create_time__,
                    creator: creator__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.resourcemanager.v1beta1.Project",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ProjectQuota {
    #[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.max_instances.is_some() {
            len += 1;
        }
        if self.max_vcpu.is_some() {
            len += 1;
        }
        if self.max_volume_gib.is_some() {
            len += 1;
        }
        if self.max_vpcs.is_some() {
            len += 1;
        }
        if self.max_public_ips.is_some() {
            len += 1;
        }
        if self.max_hosted_zones.is_some() {
            len += 1;
        }
        if self.max_record_sets.is_some() {
            len += 1;
        }
        if self.usage.is_some() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.resourcemanager.v1beta1.ProjectQuota", len)?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        if let Some(v) = self.max_instances.as_ref() {
            #[allow(clippy::needless_borrow)]
            #[allow(clippy::needless_borrows_for_generic_args)]
            struct_ser
                .serialize_field("maxInstances", ToString::to_string(&v).as_str())?;
        }
        if let Some(v) = self.max_vcpu.as_ref() {
            #[allow(clippy::needless_borrow)]
            #[allow(clippy::needless_borrows_for_generic_args)]
            struct_ser.serialize_field("maxVcpu", ToString::to_string(&v).as_str())?;
        }
        if let Some(v) = self.max_volume_gib.as_ref() {
            #[allow(clippy::needless_borrow)]
            #[allow(clippy::needless_borrows_for_generic_args)]
            struct_ser
                .serialize_field("maxVolumeGib", ToString::to_string(&v).as_str())?;
        }
        if let Some(v) = self.max_vpcs.as_ref() {
            #[allow(clippy::needless_borrow)]
            #[allow(clippy::needless_borrows_for_generic_args)]
            struct_ser.serialize_field("maxVpcs", ToString::to_string(&v).as_str())?;
        }
        if let Some(v) = self.max_public_ips.as_ref() {
            #[allow(clippy::needless_borrow)]
            #[allow(clippy::needless_borrows_for_generic_args)]
            struct_ser
                .serialize_field("maxPublicIps", ToString::to_string(&v).as_str())?;
        }
        if let Some(v) = self.max_hosted_zones.as_ref() {
            #[allow(clippy::needless_borrow)]
            #[allow(clippy::needless_borrows_for_generic_args)]
            struct_ser
                .serialize_field("maxHostedZones", ToString::to_string(&v).as_str())?;
        }
        if let Some(v) = self.max_record_sets.as_ref() {
            #[allow(clippy::needless_borrow)]
            #[allow(clippy::needless_borrows_for_generic_args)]
            struct_ser
                .serialize_field("maxRecordSets", ToString::to_string(&v).as_str())?;
        }
        if let Some(v) = self.usage.as_ref() {
            struct_ser.serialize_field("usage", v)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ProjectQuota {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "name",
            "max_instances",
            "maxInstances",
            "max_vcpu",
            "maxVcpu",
            "max_volume_gib",
            "maxVolumeGib",
            "max_vpcs",
            "maxVpcs",
            "max_public_ips",
            "maxPublicIps",
            "max_hosted_zones",
            "maxHostedZones",
            "max_record_sets",
            "maxRecordSets",
            "usage",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            MaxInstances,
            MaxVcpu,
            MaxVolumeGib,
            MaxVpcs,
            MaxPublicIps,
            MaxHostedZones,
            MaxRecordSets,
            Usage,
            __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),
                            "maxInstances" | "max_instances" => {
                                Ok(GeneratedField::MaxInstances)
                            }
                            "maxVcpu" | "max_vcpu" => Ok(GeneratedField::MaxVcpu),
                            "maxVolumeGib" | "max_volume_gib" => {
                                Ok(GeneratedField::MaxVolumeGib)
                            }
                            "maxVpcs" | "max_vpcs" => Ok(GeneratedField::MaxVpcs),
                            "maxPublicIps" | "max_public_ips" => {
                                Ok(GeneratedField::MaxPublicIps)
                            }
                            "maxHostedZones" | "max_hosted_zones" => {
                                Ok(GeneratedField::MaxHostedZones)
                            }
                            "maxRecordSets" | "max_record_sets" => {
                                Ok(GeneratedField::MaxRecordSets)
                            }
                            "usage" => Ok(GeneratedField::Usage),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = ProjectQuota;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.resourcemanager.v1beta1.ProjectQuota")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ProjectQuota, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                let mut max_instances__ = None;
                let mut max_vcpu__ = None;
                let mut max_volume_gib__ = None;
                let mut max_vpcs__ = None;
                let mut max_public_ips__ = None;
                let mut max_hosted_zones__ = None;
                let mut max_record_sets__ = None;
                let mut usage__ = 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::MaxInstances => {
                            if max_instances__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("maxInstances"),
                                );
                            }
                            max_instances__ = map_
                                .next_value::<
                                    ::std::option::Option<
                                        ::pbjson::private::NumberDeserialize<_>,
                                    >,
                                >()?
                                .map(|x| x.0);
                        }
                        GeneratedField::MaxVcpu => {
                            if max_vcpu__.is_some() {
                                return Err(serde::de::Error::duplicate_field("maxVcpu"));
                            }
                            max_vcpu__ = map_
                                .next_value::<
                                    ::std::option::Option<
                                        ::pbjson::private::NumberDeserialize<_>,
                                    >,
                                >()?
                                .map(|x| x.0);
                        }
                        GeneratedField::MaxVolumeGib => {
                            if max_volume_gib__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("maxVolumeGib"),
                                );
                            }
                            max_volume_gib__ = map_
                                .next_value::<
                                    ::std::option::Option<
                                        ::pbjson::private::NumberDeserialize<_>,
                                    >,
                                >()?
                                .map(|x| x.0);
                        }
                        GeneratedField::MaxVpcs => {
                            if max_vpcs__.is_some() {
                                return Err(serde::de::Error::duplicate_field("maxVpcs"));
                            }
                            max_vpcs__ = map_
                                .next_value::<
                                    ::std::option::Option<
                                        ::pbjson::private::NumberDeserialize<_>,
                                    >,
                                >()?
                                .map(|x| x.0);
                        }
                        GeneratedField::MaxPublicIps => {
                            if max_public_ips__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("maxPublicIps"),
                                );
                            }
                            max_public_ips__ = map_
                                .next_value::<
                                    ::std::option::Option<
                                        ::pbjson::private::NumberDeserialize<_>,
                                    >,
                                >()?
                                .map(|x| x.0);
                        }
                        GeneratedField::MaxHostedZones => {
                            if max_hosted_zones__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("maxHostedZones"),
                                );
                            }
                            max_hosted_zones__ = map_
                                .next_value::<
                                    ::std::option::Option<
                                        ::pbjson::private::NumberDeserialize<_>,
                                    >,
                                >()?
                                .map(|x| x.0);
                        }
                        GeneratedField::MaxRecordSets => {
                            if max_record_sets__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("maxRecordSets"),
                                );
                            }
                            max_record_sets__ = map_
                                .next_value::<
                                    ::std::option::Option<
                                        ::pbjson::private::NumberDeserialize<_>,
                                    >,
                                >()?
                                .map(|x| x.0);
                        }
                        GeneratedField::Usage => {
                            if usage__.is_some() {
                                return Err(serde::de::Error::duplicate_field("usage"));
                            }
                            usage__ = map_.next_value()?;
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(ProjectQuota {
                    name: name__.unwrap_or_default(),
                    max_instances: max_instances__,
                    max_vcpu: max_vcpu__,
                    max_volume_gib: max_volume_gib__,
                    max_vpcs: max_vpcs__,
                    max_public_ips: max_public_ips__,
                    max_hosted_zones: max_hosted_zones__,
                    max_record_sets: max_record_sets__,
                    usage: usage__,
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.resourcemanager.v1beta1.ProjectQuota",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for QuotaUsage {
    #[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.instances != 0 {
            len += 1;
        }
        if self.vcpu != 0 {
            len += 1;
        }
        if self.volume_gib != 0 {
            len += 1;
        }
        if self.vpcs != 0 {
            len += 1;
        }
        if self.public_ips != 0 {
            len += 1;
        }
        if self.hosted_zones.is_some() {
            len += 1;
        }
        if self.record_sets.is_some() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.resourcemanager.v1beta1.QuotaUsage", len)?;
        if self.instances != 0 {
            #[allow(clippy::needless_borrow)]
            #[allow(clippy::needless_borrows_for_generic_args)]
            struct_ser
                .serialize_field(
                    "instances",
                    ToString::to_string(&self.instances).as_str(),
                )?;
        }
        if self.vcpu != 0 {
            #[allow(clippy::needless_borrow)]
            #[allow(clippy::needless_borrows_for_generic_args)]
            struct_ser
                .serialize_field("vcpu", ToString::to_string(&self.vcpu).as_str())?;
        }
        if self.volume_gib != 0 {
            #[allow(clippy::needless_borrow)]
            #[allow(clippy::needless_borrows_for_generic_args)]
            struct_ser
                .serialize_field(
                    "volumeGib",
                    ToString::to_string(&self.volume_gib).as_str(),
                )?;
        }
        if self.vpcs != 0 {
            #[allow(clippy::needless_borrow)]
            #[allow(clippy::needless_borrows_for_generic_args)]
            struct_ser
                .serialize_field("vpcs", ToString::to_string(&self.vpcs).as_str())?;
        }
        if self.public_ips != 0 {
            #[allow(clippy::needless_borrow)]
            #[allow(clippy::needless_borrows_for_generic_args)]
            struct_ser
                .serialize_field(
                    "publicIps",
                    ToString::to_string(&self.public_ips).as_str(),
                )?;
        }
        if let Some(v) = self.hosted_zones.as_ref() {
            #[allow(clippy::needless_borrow)]
            #[allow(clippy::needless_borrows_for_generic_args)]
            struct_ser.serialize_field("hostedZones", ToString::to_string(&v).as_str())?;
        }
        if let Some(v) = self.record_sets.as_ref() {
            #[allow(clippy::needless_borrow)]
            #[allow(clippy::needless_borrows_for_generic_args)]
            struct_ser.serialize_field("recordSets", ToString::to_string(&v).as_str())?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for QuotaUsage {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "instances",
            "vcpu",
            "volume_gib",
            "volumeGib",
            "vpcs",
            "public_ips",
            "publicIps",
            "hosted_zones",
            "hostedZones",
            "record_sets",
            "recordSets",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Instances,
            Vcpu,
            VolumeGib,
            Vpcs,
            PublicIps,
            HostedZones,
            RecordSets,
            __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 {
                            "instances" => Ok(GeneratedField::Instances),
                            "vcpu" => Ok(GeneratedField::Vcpu),
                            "volumeGib" | "volume_gib" => Ok(GeneratedField::VolumeGib),
                            "vpcs" => Ok(GeneratedField::Vpcs),
                            "publicIps" | "public_ips" => Ok(GeneratedField::PublicIps),
                            "hostedZones" | "hosted_zones" => {
                                Ok(GeneratedField::HostedZones)
                            }
                            "recordSets" | "record_sets" => {
                                Ok(GeneratedField::RecordSets)
                            }
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = QuotaUsage;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.resourcemanager.v1beta1.QuotaUsage")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<QuotaUsage, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut instances__ = None;
                let mut vcpu__ = None;
                let mut volume_gib__ = None;
                let mut vpcs__ = None;
                let mut public_ips__ = None;
                let mut hosted_zones__ = None;
                let mut record_sets__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Instances => {
                            if instances__.is_some() {
                                return Err(serde::de::Error::duplicate_field("instances"));
                            }
                            instances__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::Vcpu => {
                            if vcpu__.is_some() {
                                return Err(serde::de::Error::duplicate_field("vcpu"));
                            }
                            vcpu__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::VolumeGib => {
                            if volume_gib__.is_some() {
                                return Err(serde::de::Error::duplicate_field("volumeGib"));
                            }
                            volume_gib__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::Vpcs => {
                            if vpcs__.is_some() {
                                return Err(serde::de::Error::duplicate_field("vpcs"));
                            }
                            vpcs__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::PublicIps => {
                            if public_ips__.is_some() {
                                return Err(serde::de::Error::duplicate_field("publicIps"));
                            }
                            public_ips__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::HostedZones => {
                            if hosted_zones__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("hostedZones"),
                                );
                            }
                            hosted_zones__ = map_
                                .next_value::<
                                    ::std::option::Option<
                                        ::pbjson::private::NumberDeserialize<_>,
                                    >,
                                >()?
                                .map(|x| x.0);
                        }
                        GeneratedField::RecordSets => {
                            if record_sets__.is_some() {
                                return Err(serde::de::Error::duplicate_field("recordSets"));
                            }
                            record_sets__ = map_
                                .next_value::<
                                    ::std::option::Option<
                                        ::pbjson::private::NumberDeserialize<_>,
                                    >,
                                >()?
                                .map(|x| x.0);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(QuotaUsage {
                    instances: instances__.unwrap_or_default(),
                    vcpu: vcpu__.unwrap_or_default(),
                    volume_gib: volume_gib__.unwrap_or_default(),
                    vpcs: vpcs__.unwrap_or_default(),
                    public_ips: public_ips__.unwrap_or_default(),
                    hosted_zones: hosted_zones__,
                    record_sets: record_sets__,
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.resourcemanager.v1beta1.QuotaUsage",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for UpdateOrganizationRequest {
    #[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_some() {
            len += 1;
        }
        if self.update_mask.is_some() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.resourcemanager.v1beta1.UpdateOrganizationRequest",
                len,
            )?;
        if let Some(v) = self.organization.as_ref() {
            struct_ser.serialize_field("organization", 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 UpdateOrganizationRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["organization", "update_mask", "updateMask"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Organization,
            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 {
                            "organization" => Ok(GeneratedField::Organization),
                            "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 = UpdateOrganizationRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.resourcemanager.v1beta1.UpdateOrganizationRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<UpdateOrganizationRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut organization__ = None;
                let mut update_mask__ = 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__ = 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(UpdateOrganizationRequest {
                    organization: organization__,
                    update_mask: update_mask__,
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.resourcemanager.v1beta1.UpdateOrganizationRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for UpdateProjectQuotaRequest {
    #[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_quota.is_some() {
            len += 1;
        }
        if self.update_mask.is_some() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.resourcemanager.v1beta1.UpdateProjectQuotaRequest",
                len,
            )?;
        if let Some(v) = self.project_quota.as_ref() {
            struct_ser.serialize_field("projectQuota", 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 UpdateProjectQuotaRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "project_quota",
            "projectQuota",
            "update_mask",
            "updateMask",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            ProjectQuota,
            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 {
                            "projectQuota" | "project_quota" => {
                                Ok(GeneratedField::ProjectQuota)
                            }
                            "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 = UpdateProjectQuotaRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.resourcemanager.v1beta1.UpdateProjectQuotaRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<UpdateProjectQuotaRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut project_quota__ = None;
                let mut update_mask__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::ProjectQuota => {
                            if project_quota__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("projectQuota"),
                                );
                            }
                            project_quota__ = 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(UpdateProjectQuotaRequest {
                    project_quota: project_quota__,
                    update_mask: update_mask__,
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.resourcemanager.v1beta1.UpdateProjectQuotaRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for UpdateProjectRequest {
    #[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_some() {
            len += 1;
        }
        if self.update_mask.is_some() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.resourcemanager.v1beta1.UpdateProjectRequest",
                len,
            )?;
        if let Some(v) = self.project.as_ref() {
            struct_ser.serialize_field("project", 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 UpdateProjectRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["project", "update_mask", "updateMask"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Project,
            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 {
                            "project" => Ok(GeneratedField::Project),
                            "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 = UpdateProjectRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.resourcemanager.v1beta1.UpdateProjectRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<UpdateProjectRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut project__ = None;
                let mut update_mask__ = 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__ = 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(UpdateProjectRequest {
                    project: project__,
                    update_mask: update_mask__,
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.resourcemanager.v1beta1.UpdateProjectRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
/// Calls `OrganizationService`.
///
/// Organizations: the account a company's projects, members and billing
/// belong to. Every project is in exactly one organization, and access to an
/// organization is granted with roles in the IAM API (`iam.origincloudapis.eu`).
#[derive(Clone, Debug)]
pub struct OrganizationClient {
    service: ::origincloud_core::Service,
}
impl OrganizationClient {
    /// Returns a client of `OrganizationService` that sends its calls through `client`.
    pub fn new(client: &::origincloud_core::Client) -> Self {
        Self {
            service: client.service("resourcemanager", 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 an organization.
    pub async fn get_organization(
        &self,
        request: GetOrganizationRequest,
    ) -> ::core::result::Result<Organization, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "name",
            &request.name,
            "organizations/*",
        )?;
        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 organizations the caller holds a role in, oldest first.
    pub async fn list_organizations(
        &self,
        request: ListOrganizationsRequest,
    ) -> ::core::result::Result<ListOrganizationsResponse, ::origincloud_core::Error> {
        let query = ::origincloud_core::query(&request, &[])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::GET,
                ::std::string::String::from("/v1beta1/organizations"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Returns everything [`list_organizations`](Self::list_organizations) 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_organizations(
        &self,
        request: ListOrganizationsRequest,
    ) -> ::origincloud_core::Pages<Organization> {
        let client = self.clone();
        ::origincloud_core::Pages::new(
            request,
            move |request: ListOrganizationsRequest| {
                let client = client.clone();
                async move {
                    let page = client.list_organizations(request).await?;
                    Ok((page.organizations, page.next_page_token))
                }
            },
            |request: &mut ListOrganizationsRequest, token: ::std::string::String| {
                request.page_token = token;
            },
        )
    }
    /// Creates an organization. Any signed-in user can create one, and becomes
    /// its owner and the administrator of its default billing account, which
    /// is created with it without billing details: the organization can't be
    /// invoiced until they are set with the billing API
    /// (`billing.origincloudapis.eu`). A new organization is either `organization::State::Active`
    /// at once or `organization::State::PendingReview`, depending on the platform's free capacity.
    pub async fn create_organization(
        &self,
        mut request: CreateOrganizationRequest,
    ) -> ::core::result::Result<Organization, ::origincloud_core::Error> {
        if request.request_id.is_empty() {
            request.request_id = ::origincloud_core::new_request_id();
        }
        let body = ::origincloud_core::json_body(
            request.organization.as_ref().unwrap_or(&::core::default::Default::default()),
        )?;
        let query = ::origincloud_core::query(&request, &["organization"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::POST,
                ::std::string::String::from("/v1beta1/organizations"),
            )
            .with_body(body)
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Renames an organization.
    pub async fn update_organization(
        &self,
        request: UpdateOrganizationRequest,
    ) -> ::core::result::Result<Organization, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "organization.name",
            request.organization.as_ref().map_or("", |m| m.name.as_str()),
            "organizations/*",
        )?;
        let body = ::origincloud_core::json_body(
            request.organization.as_ref().unwrap_or(&::core::default::Default::default()),
        )?;
        let query = ::origincloud_core::query(
            &request,
            &["organization.name", "organization"],
        )?;
        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 an organization. Refused as a `CONFLICT` while it
    /// still has a project, or a service account that isn't deleted, which
    /// the error names: delete them first. Nothing is deleted then. Its quota,
    /// its pending invitations and every role granted in it go with it. Its
    /// billing accounts stay, with their spend limits, so the last period can
    /// still be invoiced.
    pub async fn delete_organization(
        &self,
        request: DeleteOrganizationRequest,
    ) -> ::core::result::Result<
        ::origincloud_core::protobuf::Empty,
        ::origincloud_core::Error,
    > {
        let p0 = ::origincloud_core::path_value(
            "name",
            &request.name,
            "organizations/*",
        )?;
        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
    }
    /// Returns an organization's quota: the most of each kind of resource its
    /// projects may hold together, and how much of it they use. The limits are
    /// set by the platform; ask support to raise one.
    pub async fn get_organization_quota(
        &self,
        request: GetOrganizationQuotaRequest,
    ) -> ::core::result::Result<OrganizationQuota, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "name",
            &request.name,
            "organizations/*/quota",
        )?;
        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
    }
}
/// Calls `ProjectService`.
///
/// Projects: the namespace every resource is created in. A project belongs to
/// one organization, and every resource name of the other APIs starts with
/// it, `projects/{project}/...`.
#[derive(Clone, Debug)]
pub struct ProjectClient {
    service: ::origincloud_core::Service,
}
impl ProjectClient {
    /// Returns a client of `ProjectService` that sends its calls through `client`.
    pub fn new(client: &::origincloud_core::Client) -> Self {
        Self {
            service: client.service("resourcemanager", 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.
    pub async fn get_project(
        &self,
        request: GetProjectRequest,
    ) -> ::core::result::Result<Project, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value("name", &request.name, "projects/*")?;
        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 projects, oldest first.
    pub async fn list_projects(
        &self,
        request: ListProjectsRequest,
    ) -> ::core::result::Result<ListProjectsResponse, ::origincloud_core::Error> {
        let query = ::origincloud_core::query(&request, &[])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::GET,
                ::std::string::String::from("/v1beta1/projects"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Returns everything [`list_projects`](Self::list_projects) 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_projects(
        &self,
        request: ListProjectsRequest,
    ) -> ::origincloud_core::Pages<Project> {
        let client = self.clone();
        ::origincloud_core::Pages::new(
            request,
            move |request: ListProjectsRequest| {
                let client = client.clone();
                async move {
                    let page = client.list_projects(request).await?;
                    Ok((page.projects, page.next_page_token))
                }
            },
            |request: &mut ListProjectsRequest, token: ::std::string::String| {
                request.page_token = token;
            },
        )
    }
    /// Creates a project in an `organization::State::Active` organization, under the id the caller
    /// chooses. The caller becomes the project's owner, and the project is
    /// billed to the organization's default billing account. An id in use, or
    /// used by a project that was deleted, is refused as a `CONFLICT`.
    pub async fn create_project(
        &self,
        mut request: CreateProjectRequest,
    ) -> ::core::result::Result<Project, ::origincloud_core::Error> {
        if request.request_id.is_empty() {
            request.request_id = ::origincloud_core::new_request_id();
        }
        let body = ::origincloud_core::json_body(
            request.project.as_ref().unwrap_or(&::core::default::Default::default()),
        )?;
        let query = ::origincloud_core::query(&request, &["project"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::POST,
                ::std::string::String::from("/v1beta1/projects"),
            )
            .with_body(body)
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Renames a project.
    pub async fn update_project(
        &self,
        request: UpdateProjectRequest,
    ) -> ::core::result::Result<Project, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "project.name",
            request.project.as_ref().map_or("", |m| m.name.as_str()),
            "projects/*",
        )?;
        let body = ::origincloud_core::json_body(
            request.project.as_ref().unwrap_or(&::core::default::Default::default()),
        )?;
        let query = ::origincloud_core::query(&request, &["project.name", "project"])?;
        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 project. Refused as a `CONFLICT` while the project
    /// still has a resource you can delete yourself: an instance that isn't terminated, an image, a key
    /// pair, a volume or snapshot that isn't deleted, a NAT gateway, a floating
    /// IP, a VPC, or a DNS policy other than its default one. The refusal names
    /// every kind left, in the order to delete them. Nothing you can delete
    /// yourself is deleted on your behalf. The project's default DNS policy,
    /// its quota and every role granted on it go with it; roles granted on the
    /// organization stay.
    pub async fn delete_project(
        &self,
        request: DeleteProjectRequest,
    ) -> ::core::result::Result<
        ::origincloud_core::protobuf::Empty,
        ::origincloud_core::Error,
    > {
        let p0 = ::origincloud_core::path_value("name", &request.name, "projects/*")?;
        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
    }
    /// Returns a project's quota: the budget of each kind of resource the
    /// project may hold, if one is set, and how much of it the project uses.
    pub async fn get_project_quota(
        &self,
        request: GetProjectQuotaRequest,
    ) -> ::core::result::Result<ProjectQuota, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "name",
            &request.name,
            "projects/*/quota",
        )?;
        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 project's budgets. A budget named in `update_mask`
    /// is set to the value given, or removed when the value is left out.
    pub async fn update_project_quota(
        &self,
        request: UpdateProjectQuotaRequest,
    ) -> ::core::result::Result<ProjectQuota, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "projectQuota.name",
            request.project_quota.as_ref().map_or("", |m| m.name.as_str()),
            "projects/*/quota",
        )?;
        let body = ::origincloud_core::json_body(
            request
                .project_quota
                .as_ref()
                .unwrap_or(&::core::default::Default::default()),
        )?;
        let query = ::origincloud_core::query(
            &request,
            &["projectQuota.name", "projectQuota"],
        )?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::PATCH,
                format!("/v1beta1/{p0}"),
            )
            .with_body(body)
            .with_query(query);
        self.service.call(call).await
    }
}