origincloud_dns/generated/

origincloud.dns.v1beta1.rs

// Code generated by origincloud-sdk-generator. DO NOT EDIT.
// source: origincloud/dns/v1beta1/hosted_zone.proto
// source: origincloud/dns/v1beta1/record_set.proto
// source: origincloud/dns/v1beta1/vpc_attachment.proto

/// A domain a project's records are answered for.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HostedZone {
    /// The zone's resource name.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The zone's URN, the identifier access policies and the audit log use.
    #[prost(string, tag = "2")]
    pub urn: ::prost::alloc::string::String,
    /// The domain, such as `example.com`, without the final dot; answered in
    /// lowercase. A public zone's has at least two labels and at most 235
    /// characters, so its challenge name fits. A private zone's may have one
    /// label, but isn't `internal` or a name below it, which answer each
    /// instance's own name. Neither is one of the platform's own domains or a
    /// name below one.
    #[prost(string, tag = "3")]
    pub dns_name: ::prost::alloc::string::String,
    /// Where the zone is answered.
    #[prost(enumeration = "hosted_zone::Visibility", tag = "4")]
    pub visibility: i32,
    /// Whether the zone is answered.
    #[prost(enumeration = "hosted_zone::State", tag = "5")]
    pub state: i32,
    /// The name servers to delegate a public zone to at its registrar, as NS
    /// records of its name. Fixed when the zone is created. Empty for a
    /// private zone.
    #[prost(string, repeated, tag = "6")]
    pub name_servers: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// How a public zone proves control of its name, and how it went. Unset
    /// for a private zone.
    #[prost(message, optional, tag = "7")]
    pub challenge: ::core::option::Option<OwnershipChallenge>,
    /// When the zone was created.
    #[prost(message, optional, tag = "8")]
    pub create_time: ::core::option::Option<::origincloud_core::protobuf::Timestamp>,
    /// The principal that created the zone, such as `user:<id>` or
    /// `service_account:<id>`.
    #[prost(string, tag = "9")]
    pub creator: ::prost::alloc::string::String,
    /// Labels of your own, at most 50. The `origin:name` tag is the name the
    /// console shows.
    #[prost(btree_map = "string, string", tag = "10")]
    pub tags: ::prost::alloc::collections::BTreeMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
/// Nested message and enum types in `HostedZone`.
pub mod hosted_zone {
    /// Where a zone is answered.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Visibility {
        /// Not set.
        Unspecified = 0,
        /// On the internet, from the platform's name servers.
        Public = 1,
        /// Only inside the VPCs it is attached to.
        Private = 2,
    }
    impl Visibility {
        /// 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 => "VISIBILITY_UNSPECIFIED",
                Self::Public => "PUBLIC",
                Self::Private => "PRIVATE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "VISIBILITY_UNSPECIFIED" => Some(Self::Unspecified),
                "PUBLIC" => Some(Self::Public),
                "PRIVATE" => Some(Self::Private),
                _ => None,
            }
        }
    }
    /// Whether a zone is answered.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        /// Not set.
        Unspecified = 0,
        /// A public zone that hasn't proved control of its name yet: not
        /// answered, and holding no name.
        PendingVerification = 1,
        /// Answered. A public zone in this state holds its name.
        Active = 2,
        /// A public zone that lost control of its name: not answered, its
        /// record sets kept, its name free for another zone.
        Suspended = 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::PendingVerification => "PENDING_VERIFICATION",
                Self::Active => "ACTIVE",
                Self::Suspended => "SUSPENDED",
            }
        }
        /// 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_VERIFICATION" => Some(Self::PendingVerification),
                "ACTIVE" => Some(Self::Active),
                "SUSPENDED" => Some(Self::Suspended),
                _ => None,
            }
        }
    }
}
/// A public zone's proof of control of its name: a TXT record named
/// `dns_name` whose value is `token`, answered by the name's current DNS.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct OwnershipChallenge {
    /// The name of the TXT record to create where the zone's name is hosted
    /// now: `_origin-challenge.` followed by the zone's `dns_name`.
    #[prost(string, tag = "1")]
    pub dns_name: ::prost::alloc::string::String,
    /// The value the TXT record holds.
    #[prost(string, tag = "2")]
    pub token: ::prost::alloc::string::String,
    /// When a pending zone that hasn't verified is deleted; unset once it
    /// verified.
    #[prost(message, optional, tag = "3")]
    pub expire_time: ::core::option::Option<::origincloud_core::protobuf::Timestamp>,
    /// When the zone verified; unset while it is pending.
    #[prost(message, optional, tag = "4")]
    pub verify_time: ::core::option::Option<::origincloud_core::protobuf::Timestamp>,
    /// When the zone was suspended; unset unless it is `hosted_zone::State::Suspended`.
    #[prost(message, optional, tag = "5")]
    pub suspend_time: ::core::option::Option<::origincloud_core::protobuf::Timestamp>,
    /// Why the zone was suspended; unset unless it is `hosted_zone::State::Suspended`.
    #[prost(enumeration = "ownership_challenge::SuspensionReason", tag = "6")]
    pub suspension_reason: i32,
    /// What the check `VerifyHostedZone` made found. Set only in that
    /// method's response.
    #[prost(enumeration = "ownership_challenge::CheckOutcome", tag = "7")]
    pub last_check: i32,
}
/// Nested message and enum types in `OwnershipChallenge`.
pub mod ownership_challenge {
    /// Why a zone was suspended.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum SuspensionReason {
        /// Not set.
        Unspecified = 0,
        /// Several daily checks in a row found the name delegated to other name
        /// servers, without the zone's token.
        ChallengeLost = 1,
    }
    impl SuspensionReason {
        /// 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 => "SUSPENSION_REASON_UNSPECIFIED",
                Self::ChallengeLost => "CHALLENGE_LOST",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "SUSPENSION_REASON_UNSPECIFIED" => Some(Self::Unspecified),
                "CHALLENGE_LOST" => Some(Self::ChallengeLost),
                _ => None,
            }
        }
    }
    /// What a check of the challenge found.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum CheckOutcome {
        /// Not set.
        Unspecified = 0,
        /// The token answers, and the zone holds its name: it is `hosted_zone::State::Active`.
        Ok = 1,
        /// The token doesn't answer at the TXT record's name, or the name's DNS
        /// can't be asked.
        NotFound = 2,
        /// The token answers, but another zone holds the name.
        NameHeld = 3,
    }
    impl CheckOutcome {
        /// 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 => "CHECK_OUTCOME_UNSPECIFIED",
                Self::Ok => "OK",
                Self::NotFound => "NOT_FOUND",
                Self::NameHeld => "NAME_HELD",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "CHECK_OUTCOME_UNSPECIFIED" => Some(Self::Unspecified),
                "OK" => Some(Self::Ok),
                "NOT_FOUND" => Some(Self::NotFound),
                "NAME_HELD" => Some(Self::NameHeld),
                _ => None,
            }
        }
    }
}
/// The request for GetHostedZone.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetHostedZoneRequest {
    /// The zone to return.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request for ListHostedZones.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListHostedZonesRequest {
    /// The project whose zones to list, `projects/{project}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The most zones 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,
    /// Only the zones of this domain, written as `dns_name` is; every zone
    /// when left empty.
    #[prost(string, tag = "4")]
    pub dns_name: ::prost::alloc::string::String,
}
/// The response for ListHostedZones.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListHostedZonesResponse {
    /// The zones on this page.
    #[prost(message, repeated, tag = "1")]
    pub hosted_zones: ::prost::alloc::vec::Vec<HostedZone>,
    /// 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 CreateHostedZone.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateHostedZoneRequest {
    /// The project to create the zone in, `projects/{project}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The zone to create: its `dns_name`, `visibility` and optionally its
    /// `tags`.
    #[prost(message, optional, tag = "2")]
    pub hosted_zone: ::core::option::Option<HostedZone>,
    /// A UUID; a repeat with the same id within a day returns the zone the
    /// first request created, as it is now, instead of creating a second one.
    #[prost(string, tag = "3")]
    pub request_id: ::prost::alloc::string::String,
}
/// The request for UpdateHostedZone.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateHostedZoneRequest {
    /// The zone, by its name, with the fields to change.
    #[prost(message, optional, tag = "1")]
    pub hosted_zone: ::core::option::Option<HostedZone>,
    /// The fields to change: `tags`, or `*`.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::origincloud_core::protobuf::FieldMask>,
    /// A UUID; a repeat with the same id within a day returns the zone as it
    /// is now, instead of changing it again.
    #[prost(string, tag = "3")]
    pub request_id: ::prost::alloc::string::String,
}
/// The request for DeleteHostedZone.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteHostedZoneRequest {
    /// The zone to delete.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// A UUID; a repeat with the same id within a day succeeds as the first
    /// did, instead of answering `ownership_challenge::CheckOutcome::NotFound`.
    #[prost(string, tag = "2")]
    pub request_id: ::prost::alloc::string::String,
}
/// The request for VerifyHostedZone.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct VerifyHostedZoneRequest {
    /// The public zone to verify.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Every record of one name and type in a hosted zone.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RecordSet {
    /// The record set's resource name.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The record set's URN, the identifier access policies and the audit log
    /// use.
    #[prost(string, tag = "2")]
    pub urn: ::prost::alloc::string::String,
    /// The name the records answer for: the zone's `dns_name` or a name below
    /// it, written in full, such as `www.example.com`, without the final dot;
    /// answered in lowercase. Labels may hold `_` (`_dmarc.example.com`), and
    /// `*` only as the whole leftmost label, for a wildcard.
    #[prost(string, tag = "3")]
    pub dns_name: ::prost::alloc::string::String,
    /// The records' type. An alias is `record_set::Type::A`.
    #[prost(enumeration = "record_set::Type", tag = "4")]
    pub r#type: i32,
    /// How long resolvers may keep the answer, from 30 seconds to 7 days, in
    /// whole seconds. 300 seconds when left out.
    #[prost(message, optional, tag = "5")]
    pub ttl: ::core::option::Option<::origincloud_core::protobuf::Duration>,
    /// When the record set was created.
    #[prost(message, optional, tag = "8")]
    pub create_time: ::core::option::Option<::origincloud_core::protobuf::Timestamp>,
    /// When the record set was last changed.
    #[prost(message, optional, tag = "9")]
    pub update_time: ::core::option::Option<::origincloud_core::protobuf::Timestamp>,
    /// What the record set answers with: exactly one of these.
    #[prost(oneof = "record_set::Data", tags = "6, 7")]
    pub data: ::core::option::Option<record_set::Data>,
}
/// Nested message and enum types in `RecordSet`.
pub mod record_set {
    /// A record type.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Type {
        /// Not set.
        Unspecified = 0,
        /// IPv4 addresses.
        A = 1,
        /// IPv6 addresses.
        Aaaa = 2,
        /// Another name this one is an alias of.
        Cname = 3,
        /// Text.
        Txt = 4,
        /// Mail exchangers.
        Mx = 5,
        /// Service locations.
        Srv = 6,
        /// The certificate authorities that may issue for the name.
        Caa = 7,
    }
    impl Type {
        /// 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 => "TYPE_UNSPECIFIED",
                Self::A => "A",
                Self::Aaaa => "AAAA",
                Self::Cname => "CNAME",
                Self::Txt => "TXT",
                Self::Mx => "MX",
                Self::Srv => "SRV",
                Self::Caa => "CAA",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "A" => Some(Self::A),
                "AAAA" => Some(Self::Aaaa),
                "CNAME" => Some(Self::Cname),
                "TXT" => Some(Self::Txt),
                "MX" => Some(Self::Mx),
                "SRV" => Some(Self::Srv),
                "CAA" => Some(Self::Caa),
                _ => None,
            }
        }
    }
    /// What the record set answers with: exactly one of these.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Data {
        /// Values of its own.
        #[prost(message, tag = "6")]
        Basic(super::BasicRecordData),
        /// The address of a platform resource, followed as it changes.
        #[prost(message, tag = "7")]
        Alias(super::AliasRecordData),
    }
}
/// A record set's own values.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct BasicRecordData {
    /// The records' values, 1 to 100, each once, written as `type` says. Names
    /// are written in full without the final dot, and answered in lowercase.
    /// - `record_set::Type::A`: an IPv4 address, `192.0.2.10`.
    /// - `record_set::Type::Aaaa`: an IPv6 address, `2001:db8::10`.
    /// - `record_set::Type::Cname`: one name, `www.example.net`.
    /// - `record_set::Type::Txt`: the text as it is, printable ASCII, up to 4000 characters,
    ///    without quotes; it is split into strings of 255 characters on the
    ///    wire.
    /// - `record_set::Type::Mx`: `{preference} {exchange}`, `10 mail.example.com`. `0 .`, alone,
    ///    says the name takes no mail.
    /// - `record_set::Type::Srv`: `{priority} {weight} {port} {target}`,
    ///    `10 5 5060 sip.example.com`. A target of `.`, alone, says the service
    ///    isn't offered.
    /// - `record_set::Type::Caa`: `{flags} {tag} {value}`, `0 issue letsencrypt.org`: flags 0 or
    ///    128, the value as it is, without quotes.
    ///
    /// A record set's records take at most 16 KiB on the wire.
    #[prost(string, repeated, tag = "1")]
    pub values: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// An alias: the record set answers with a platform resource's address, and
/// follows it as it changes.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AliasRecordData {
    /// The Floating IP whose address the record set answers with, in the
    /// zone's project. A Floating IP's address is an IPv4 address, so the
    /// record set is of type `record_set::Type::A`; an `record_set::Type::Aaaa` alias is refused.
    #[prost(string, tag = "1")]
    pub floating_ip: ::prost::alloc::string::String,
}
/// The request for GetRecordSet.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetRecordSetRequest {
    /// The record set to return.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request for ListRecordSets.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListRecordSetsRequest {
    /// The zone whose record sets to list,
    /// `projects/{project}/hostedZones/{hosted_zone}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The most record sets 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,
    /// Only the record sets of this name, written as `dns_name` is; every
    /// name's when left empty.
    #[prost(string, tag = "4")]
    pub dns_name: ::prost::alloc::string::String,
    /// Only the record sets of this type; every type's when left unset.
    #[prost(enumeration = "record_set::Type", tag = "5")]
    pub r#type: i32,
}
/// The response for ListRecordSets.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListRecordSetsResponse {
    /// The record sets on this page.
    #[prost(message, repeated, tag = "1")]
    pub record_sets: ::prost::alloc::vec::Vec<RecordSet>,
    /// 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 CreateRecordSet.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreateRecordSetRequest {
    /// The zone to create the record set in,
    /// `projects/{project}/hostedZones/{hosted_zone}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The record set to create: its `dns_name`, `type`, optionally its
    /// `ttl`, and one of `basic` and `alias`.
    #[prost(message, optional, tag = "2")]
    pub record_set: ::core::option::Option<RecordSet>,
    /// A UUID; a repeat with the same id within a day returns the record set
    /// the first request created, as it is now, instead of being refused as a
    /// conflict.
    #[prost(string, tag = "3")]
    pub request_id: ::prost::alloc::string::String,
}
/// The request for UpdateRecordSet.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UpdateRecordSetRequest {
    /// The record set, by its name, with the fields to change.
    #[prost(message, optional, tag = "1")]
    pub record_set: ::core::option::Option<RecordSet>,
    /// The fields to change: `ttl`, `basic`, `alias`, or `*`.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::origincloud_core::protobuf::FieldMask>,
    /// A UUID; a repeat with the same id within a day returns the record set
    /// as the first request left it, instead of changing it again.
    #[prost(string, tag = "3")]
    pub request_id: ::prost::alloc::string::String,
}
/// The request for DeleteRecordSet.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteRecordSetRequest {
    /// The record set to delete.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// A UUID; a repeat with the same id within a day succeeds as the first
    /// did, instead of answering `ownership_challenge::CheckOutcome::NotFound`.
    #[prost(string, tag = "2")]
    pub request_id: ::prost::alloc::string::String,
}
/// The request for BatchChangeRecordSets.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchChangeRecordSetsRequest {
    /// The zone whose record sets to change,
    /// `projects/{project}/hostedZones/{hosted_zone}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The record sets to delete, by name.
    #[prost(string, repeated, tag = "2")]
    pub deletions: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// The record sets to change, each with the fields to change, as
    /// `UpdateRecordSet` takes them.
    #[prost(message, repeated, tag = "3")]
    pub updates: ::prost::alloc::vec::Vec<RecordSetUpdate>,
    /// The record sets to create, as `CreateRecordSet` takes them.
    #[prost(message, repeated, tag = "4")]
    pub creations: ::prost::alloc::vec::Vec<RecordSet>,
    /// A UUID; a repeat with the same id within a day answers with the record
    /// sets the first request changed and created, as they are now, instead of
    /// making the changes again.
    #[prost(string, tag = "5")]
    pub request_id: ::prost::alloc::string::String,
}
/// One change of a `BatchChangeRecordSets` request.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RecordSetUpdate {
    /// The record set, by its name, with the fields to change.
    #[prost(message, optional, tag = "1")]
    pub record_set: ::core::option::Option<RecordSet>,
    /// The fields to change: `ttl`, `basic`, `alias`, or `*`.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::origincloud_core::protobuf::FieldMask>,
}
/// The response for BatchChangeRecordSets.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchChangeRecordSetsResponse {
    /// The record sets changed, then those created, each in the order of the
    /// request.
    #[prost(message, repeated, tag = "1")]
    pub record_sets: ::prost::alloc::vec::Vec<RecordSet>,
}
/// A VPC a private zone answers in.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct VpcAttachment {
    /// The attachment's resource name. Its last segment is the VPC's id.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The attachment's URN, the identifier access policies and the audit log
    /// use.
    #[prost(string, tag = "2")]
    pub urn: ::prost::alloc::string::String,
    /// The VPC the zone answers in, in the zone's project.
    #[prost(string, tag = "3")]
    pub vpc: ::prost::alloc::string::String,
    /// When the zone was attached.
    #[prost(message, optional, tag = "4")]
    pub create_time: ::core::option::Option<::origincloud_core::protobuf::Timestamp>,
}
/// The request for GetVpcAttachment.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetVpcAttachmentRequest {
    /// The attachment to return.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request for ListVpcAttachments.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListVpcAttachmentsRequest {
    /// The private zone whose attachments to list,
    /// `projects/{project}/hostedZones/{hosted_zone}`, or `-` for the zone to
    /// list every zone's in the project.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The most attachments 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,
    /// Only the attachments to this VPC; every VPC's when left empty.
    #[prost(string, tag = "4")]
    pub vpc: ::prost::alloc::string::String,
}
/// The response for ListVpcAttachments.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListVpcAttachmentsResponse {
    /// The attachments on this page.
    #[prost(message, repeated, tag = "1")]
    pub vpc_attachments: ::prost::alloc::vec::Vec<VpcAttachment>,
    /// 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 CreateVpcAttachment.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreateVpcAttachmentRequest {
    /// The private zone to attach,
    /// `projects/{project}/hostedZones/{hosted_zone}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The attachment to create: its `vpc`.
    #[prost(message, optional, tag = "2")]
    pub vpc_attachment: ::core::option::Option<VpcAttachment>,
    /// A UUID; a repeat with the same id within a day returns the attachment
    /// the first request created, as it is now, instead of being refused as a
    /// conflict.
    #[prost(string, tag = "3")]
    pub request_id: ::prost::alloc::string::String,
}
/// The request for DeleteVpcAttachment.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteVpcAttachmentRequest {
    /// The attachment to delete.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// A UUID; a repeat with the same id within a day succeeds as the first
    /// did, instead of answering `ownership_challenge::CheckOutcome::NotFound`.
    #[prost(string, tag = "2")]
    pub request_id: ::prost::alloc::string::String,
}
impl serde::Serialize for AliasRecordData {
    #[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.floating_ip.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.dns.v1beta1.AliasRecordData", len)?;
        if !self.floating_ip.is_empty() {
            struct_ser.serialize_field("floatingIp", &self.floating_ip)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for AliasRecordData {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["floating_ip", "floatingIp"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            FloatingIp,
            __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 {
                            "floatingIp" | "floating_ip" => {
                                Ok(GeneratedField::FloatingIp)
                            }
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = AliasRecordData;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.dns.v1beta1.AliasRecordData")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<AliasRecordData, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut floating_ip__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::FloatingIp => {
                            if floating_ip__.is_some() {
                                return Err(serde::de::Error::duplicate_field("floatingIp"));
                            }
                            floating_ip__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(AliasRecordData {
                    floating_ip: floating_ip__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.dns.v1beta1.AliasRecordData",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for BasicRecordData {
    #[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.values.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.dns.v1beta1.BasicRecordData", len)?;
        if !self.values.is_empty() {
            struct_ser.serialize_field("values", &self.values)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for BasicRecordData {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["values"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Values,
            __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 {
                            "values" => Ok(GeneratedField::Values),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = BasicRecordData;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.dns.v1beta1.BasicRecordData")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<BasicRecordData, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut values__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Values => {
                            if values__.is_some() {
                                return Err(serde::de::Error::duplicate_field("values"));
                            }
                            values__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(BasicRecordData {
                    values: values__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.dns.v1beta1.BasicRecordData",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for BatchChangeRecordSetsRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.parent.is_empty() {
            len += 1;
        }
        if !self.deletions.is_empty() {
            len += 1;
        }
        if !self.updates.is_empty() {
            len += 1;
        }
        if !self.creations.is_empty() {
            len += 1;
        }
        if !self.request_id.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.dns.v1beta1.BatchChangeRecordSetsRequest",
                len,
            )?;
        if !self.parent.is_empty() {
            struct_ser.serialize_field("parent", &self.parent)?;
        }
        if !self.deletions.is_empty() {
            struct_ser.serialize_field("deletions", &self.deletions)?;
        }
        if !self.updates.is_empty() {
            struct_ser.serialize_field("updates", &self.updates)?;
        }
        if !self.creations.is_empty() {
            struct_ser.serialize_field("creations", &self.creations)?;
        }
        if !self.request_id.is_empty() {
            struct_ser.serialize_field("requestId", &self.request_id)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for BatchChangeRecordSetsRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "parent",
            "deletions",
            "updates",
            "creations",
            "request_id",
            "requestId",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Parent,
            Deletions,
            Updates,
            Creations,
            RequestId,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "parent" => Ok(GeneratedField::Parent),
                            "deletions" => Ok(GeneratedField::Deletions),
                            "updates" => Ok(GeneratedField::Updates),
                            "creations" => Ok(GeneratedField::Creations),
                            "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 = BatchChangeRecordSetsRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.dns.v1beta1.BatchChangeRecordSetsRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<BatchChangeRecordSetsRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut parent__ = None;
                let mut deletions__ = None;
                let mut updates__ = None;
                let mut creations__ = None;
                let mut request_id__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Parent => {
                            if parent__.is_some() {
                                return Err(serde::de::Error::duplicate_field("parent"));
                            }
                            parent__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Deletions => {
                            if deletions__.is_some() {
                                return Err(serde::de::Error::duplicate_field("deletions"));
                            }
                            deletions__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Updates => {
                            if updates__.is_some() {
                                return Err(serde::de::Error::duplicate_field("updates"));
                            }
                            updates__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Creations => {
                            if creations__.is_some() {
                                return Err(serde::de::Error::duplicate_field("creations"));
                            }
                            creations__ = 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(BatchChangeRecordSetsRequest {
                    parent: parent__.unwrap_or_default(),
                    deletions: deletions__.unwrap_or_default(),
                    updates: updates__.unwrap_or_default(),
                    creations: creations__.unwrap_or_default(),
                    request_id: request_id__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.dns.v1beta1.BatchChangeRecordSetsRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for BatchChangeRecordSetsResponse {
    #[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.record_sets.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.dns.v1beta1.BatchChangeRecordSetsResponse",
                len,
            )?;
        if !self.record_sets.is_empty() {
            struct_ser.serialize_field("recordSets", &self.record_sets)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for BatchChangeRecordSetsResponse {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["record_sets", "recordSets"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            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 {
                            "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 = BatchChangeRecordSetsResponse;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.dns.v1beta1.BatchChangeRecordSetsResponse",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<BatchChangeRecordSetsResponse, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut record_sets__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::RecordSets => {
                            if record_sets__.is_some() {
                                return Err(serde::de::Error::duplicate_field("recordSets"));
                            }
                            record_sets__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(BatchChangeRecordSetsResponse {
                    record_sets: record_sets__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.dns.v1beta1.BatchChangeRecordSetsResponse",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for CreateHostedZoneRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.parent.is_empty() {
            len += 1;
        }
        if self.hosted_zone.is_some() {
            len += 1;
        }
        if !self.request_id.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.dns.v1beta1.CreateHostedZoneRequest", len)?;
        if !self.parent.is_empty() {
            struct_ser.serialize_field("parent", &self.parent)?;
        }
        if let Some(v) = self.hosted_zone.as_ref() {
            struct_ser.serialize_field("hostedZone", v)?;
        }
        if !self.request_id.is_empty() {
            struct_ser.serialize_field("requestId", &self.request_id)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for CreateHostedZoneRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "parent",
            "hosted_zone",
            "hostedZone",
            "request_id",
            "requestId",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Parent,
            HostedZone,
            RequestId,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "parent" => Ok(GeneratedField::Parent),
                            "hostedZone" | "hosted_zone" => {
                                Ok(GeneratedField::HostedZone)
                            }
                            "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 = CreateHostedZoneRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.dns.v1beta1.CreateHostedZoneRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<CreateHostedZoneRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut parent__ = None;
                let mut hosted_zone__ = None;
                let mut request_id__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Parent => {
                            if parent__.is_some() {
                                return Err(serde::de::Error::duplicate_field("parent"));
                            }
                            parent__ = Some(map_.next_value()?);
                        }
                        GeneratedField::HostedZone => {
                            if hosted_zone__.is_some() {
                                return Err(serde::de::Error::duplicate_field("hostedZone"));
                            }
                            hosted_zone__ = 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(CreateHostedZoneRequest {
                    parent: parent__.unwrap_or_default(),
                    hosted_zone: hosted_zone__,
                    request_id: request_id__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.dns.v1beta1.CreateHostedZoneRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for CreateRecordSetRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.parent.is_empty() {
            len += 1;
        }
        if self.record_set.is_some() {
            len += 1;
        }
        if !self.request_id.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.dns.v1beta1.CreateRecordSetRequest", len)?;
        if !self.parent.is_empty() {
            struct_ser.serialize_field("parent", &self.parent)?;
        }
        if let Some(v) = self.record_set.as_ref() {
            struct_ser.serialize_field("recordSet", v)?;
        }
        if !self.request_id.is_empty() {
            struct_ser.serialize_field("requestId", &self.request_id)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for CreateRecordSetRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "parent",
            "record_set",
            "recordSet",
            "request_id",
            "requestId",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Parent,
            RecordSet,
            RequestId,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "parent" => Ok(GeneratedField::Parent),
                            "recordSet" | "record_set" => Ok(GeneratedField::RecordSet),
                            "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 = CreateRecordSetRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.dns.v1beta1.CreateRecordSetRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<CreateRecordSetRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut parent__ = None;
                let mut record_set__ = None;
                let mut request_id__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Parent => {
                            if parent__.is_some() {
                                return Err(serde::de::Error::duplicate_field("parent"));
                            }
                            parent__ = Some(map_.next_value()?);
                        }
                        GeneratedField::RecordSet => {
                            if record_set__.is_some() {
                                return Err(serde::de::Error::duplicate_field("recordSet"));
                            }
                            record_set__ = 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(CreateRecordSetRequest {
                    parent: parent__.unwrap_or_default(),
                    record_set: record_set__,
                    request_id: request_id__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.dns.v1beta1.CreateRecordSetRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for CreateVpcAttachmentRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.parent.is_empty() {
            len += 1;
        }
        if self.vpc_attachment.is_some() {
            len += 1;
        }
        if !self.request_id.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.dns.v1beta1.CreateVpcAttachmentRequest",
                len,
            )?;
        if !self.parent.is_empty() {
            struct_ser.serialize_field("parent", &self.parent)?;
        }
        if let Some(v) = self.vpc_attachment.as_ref() {
            struct_ser.serialize_field("vpcAttachment", v)?;
        }
        if !self.request_id.is_empty() {
            struct_ser.serialize_field("requestId", &self.request_id)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for CreateVpcAttachmentRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "parent",
            "vpc_attachment",
            "vpcAttachment",
            "request_id",
            "requestId",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Parent,
            VpcAttachment,
            RequestId,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "parent" => Ok(GeneratedField::Parent),
                            "vpcAttachment" | "vpc_attachment" => {
                                Ok(GeneratedField::VpcAttachment)
                            }
                            "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 = CreateVpcAttachmentRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.dns.v1beta1.CreateVpcAttachmentRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<CreateVpcAttachmentRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut parent__ = None;
                let mut vpc_attachment__ = None;
                let mut request_id__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Parent => {
                            if parent__.is_some() {
                                return Err(serde::de::Error::duplicate_field("parent"));
                            }
                            parent__ = Some(map_.next_value()?);
                        }
                        GeneratedField::VpcAttachment => {
                            if vpc_attachment__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("vpcAttachment"),
                                );
                            }
                            vpc_attachment__ = 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(CreateVpcAttachmentRequest {
                    parent: parent__.unwrap_or_default(),
                    vpc_attachment: vpc_attachment__,
                    request_id: request_id__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.dns.v1beta1.CreateVpcAttachmentRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for DeleteHostedZoneRequest {
    #[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.request_id.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.dns.v1beta1.DeleteHostedZoneRequest", len)?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        if !self.request_id.is_empty() {
            struct_ser.serialize_field("requestId", &self.request_id)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for DeleteHostedZoneRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["name", "request_id", "requestId"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            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 {
                            "name" => Ok(GeneratedField::Name),
                            "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 = DeleteHostedZoneRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.dns.v1beta1.DeleteHostedZoneRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<DeleteHostedZoneRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                let mut request_id__ = 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::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(DeleteHostedZoneRequest {
                    name: name__.unwrap_or_default(),
                    request_id: request_id__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.dns.v1beta1.DeleteHostedZoneRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for DeleteRecordSetRequest {
    #[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.request_id.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.dns.v1beta1.DeleteRecordSetRequest", len)?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        if !self.request_id.is_empty() {
            struct_ser.serialize_field("requestId", &self.request_id)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for DeleteRecordSetRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["name", "request_id", "requestId"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            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 {
                            "name" => Ok(GeneratedField::Name),
                            "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 = DeleteRecordSetRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.dns.v1beta1.DeleteRecordSetRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<DeleteRecordSetRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                let mut request_id__ = 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::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(DeleteRecordSetRequest {
                    name: name__.unwrap_or_default(),
                    request_id: request_id__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.dns.v1beta1.DeleteRecordSetRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for DeleteVpcAttachmentRequest {
    #[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.request_id.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.dns.v1beta1.DeleteVpcAttachmentRequest",
                len,
            )?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        if !self.request_id.is_empty() {
            struct_ser.serialize_field("requestId", &self.request_id)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for DeleteVpcAttachmentRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["name", "request_id", "requestId"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            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 {
                            "name" => Ok(GeneratedField::Name),
                            "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 = DeleteVpcAttachmentRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.dns.v1beta1.DeleteVpcAttachmentRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<DeleteVpcAttachmentRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                let mut request_id__ = 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::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(DeleteVpcAttachmentRequest {
                    name: name__.unwrap_or_default(),
                    request_id: request_id__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.dns.v1beta1.DeleteVpcAttachmentRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for GetHostedZoneRequest {
    #[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.dns.v1beta1.GetHostedZoneRequest", len)?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for GetHostedZoneRequest {
    #[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 = GetHostedZoneRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.dns.v1beta1.GetHostedZoneRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<GetHostedZoneRequest, 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(GetHostedZoneRequest {
                    name: name__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.dns.v1beta1.GetHostedZoneRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for GetRecordSetRequest {
    #[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.dns.v1beta1.GetRecordSetRequest", len)?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for GetRecordSetRequest {
    #[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 = GetRecordSetRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.dns.v1beta1.GetRecordSetRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<GetRecordSetRequest, 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(GetRecordSetRequest {
                    name: name__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.dns.v1beta1.GetRecordSetRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for GetVpcAttachmentRequest {
    #[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.dns.v1beta1.GetVpcAttachmentRequest", len)?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for GetVpcAttachmentRequest {
    #[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 = GetVpcAttachmentRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.dns.v1beta1.GetVpcAttachmentRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<GetVpcAttachmentRequest, 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(GetVpcAttachmentRequest {
                    name: name__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.dns.v1beta1.GetVpcAttachmentRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for HostedZone {
    #[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.dns_name.is_empty() {
            len += 1;
        }
        if self.visibility != 0 {
            len += 1;
        }
        if self.state != 0 {
            len += 1;
        }
        if !self.name_servers.is_empty() {
            len += 1;
        }
        if self.challenge.is_some() {
            len += 1;
        }
        if self.create_time.is_some() {
            len += 1;
        }
        if !self.creator.is_empty() {
            len += 1;
        }
        if !self.tags.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.dns.v1beta1.HostedZone", 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.dns_name.is_empty() {
            struct_ser.serialize_field("dnsName", &self.dns_name)?;
        }
        if self.visibility != 0 {
            let v = hosted_zone::Visibility::try_from(self.visibility)
                .map_err(|_| serde::ser::Error::custom(
                    format!("Invalid variant {}", self.visibility),
                ))?;
            struct_ser.serialize_field("visibility", &v)?;
        }
        if self.state != 0 {
            let v = hosted_zone::State::try_from(self.state)
                .map_err(|_| serde::ser::Error::custom(
                    format!("Invalid variant {}", self.state),
                ))?;
            struct_ser.serialize_field("state", &v)?;
        }
        if !self.name_servers.is_empty() {
            struct_ser.serialize_field("nameServers", &self.name_servers)?;
        }
        if let Some(v) = self.challenge.as_ref() {
            struct_ser.serialize_field("challenge", 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)?;
        }
        if !self.tags.is_empty() {
            struct_ser.serialize_field("tags", &self.tags)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for HostedZone {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "name",
            "urn",
            "dns_name",
            "dnsName",
            "visibility",
            "state",
            "name_servers",
            "nameServers",
            "challenge",
            "create_time",
            "createTime",
            "creator",
            "tags",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            Urn,
            DnsName,
            Visibility,
            State,
            NameServers,
            Challenge,
            CreateTime,
            Creator,
            Tags,
            __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),
                            "dnsName" | "dns_name" => Ok(GeneratedField::DnsName),
                            "visibility" => Ok(GeneratedField::Visibility),
                            "state" => Ok(GeneratedField::State),
                            "nameServers" | "name_servers" => {
                                Ok(GeneratedField::NameServers)
                            }
                            "challenge" => Ok(GeneratedField::Challenge),
                            "createTime" | "create_time" => {
                                Ok(GeneratedField::CreateTime)
                            }
                            "creator" => Ok(GeneratedField::Creator),
                            "tags" => Ok(GeneratedField::Tags),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = HostedZone;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.dns.v1beta1.HostedZone")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<HostedZone, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                let mut urn__ = None;
                let mut dns_name__ = None;
                let mut visibility__ = None;
                let mut state__ = None;
                let mut name_servers__ = None;
                let mut challenge__ = None;
                let mut create_time__ = None;
                let mut creator__ = None;
                let mut tags__ = 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::DnsName => {
                            if dns_name__.is_some() {
                                return Err(serde::de::Error::duplicate_field("dnsName"));
                            }
                            dns_name__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Visibility => {
                            if visibility__.is_some() {
                                return Err(serde::de::Error::duplicate_field("visibility"));
                            }
                            visibility__ = Some(
                                map_.next_value::<hosted_zone::Visibility>()? as i32,
                            );
                        }
                        GeneratedField::State => {
                            if state__.is_some() {
                                return Err(serde::de::Error::duplicate_field("state"));
                            }
                            state__ = Some(
                                map_.next_value::<hosted_zone::State>()? as i32,
                            );
                        }
                        GeneratedField::NameServers => {
                            if name_servers__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("nameServers"),
                                );
                            }
                            name_servers__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Challenge => {
                            if challenge__.is_some() {
                                return Err(serde::de::Error::duplicate_field("challenge"));
                            }
                            challenge__ = 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::Tags => {
                            if tags__.is_some() {
                                return Err(serde::de::Error::duplicate_field("tags"));
                            }
                            tags__ = Some(
                                map_.next_value::<std::collections::BTreeMap<_, _>>()?,
                            );
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(HostedZone {
                    name: name__.unwrap_or_default(),
                    urn: urn__.unwrap_or_default(),
                    dns_name: dns_name__.unwrap_or_default(),
                    visibility: visibility__.unwrap_or_default(),
                    state: state__.unwrap_or_default(),
                    name_servers: name_servers__.unwrap_or_default(),
                    challenge: challenge__,
                    create_time: create_time__,
                    creator: creator__.unwrap_or_default(),
                    tags: tags__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.dns.v1beta1.HostedZone",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for hosted_zone::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::PendingVerification => "PENDING_VERIFICATION",
            Self::Active => "ACTIVE",
            Self::Suspended => "SUSPENDED",
        };
        serializer.serialize_str(variant)
    }
}
impl<'de> serde::Deserialize<'de> for hosted_zone::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_VERIFICATION",
            "ACTIVE",
            "SUSPENDED",
        ];
        struct GeneratedVisitor;
        impl serde::de::Visitor<'_> for GeneratedVisitor {
            type Value = hosted_zone::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(hosted_zone::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(hosted_zone::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(hosted_zone::State::Unspecified),
                    "PENDING_VERIFICATION" => Ok(hosted_zone::State::PendingVerification),
                    "ACTIVE" => Ok(hosted_zone::State::Active),
                    "SUSPENDED" => Ok(hosted_zone::State::Suspended),
                    _ => Ok(hosted_zone::State::default()),
                }
            }
        }
        deserializer.deserialize_any(GeneratedVisitor)
    }
}
impl serde::Serialize for hosted_zone::Visibility {
    #[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 => "VISIBILITY_UNSPECIFIED",
            Self::Public => "PUBLIC",
            Self::Private => "PRIVATE",
        };
        serializer.serialize_str(variant)
    }
}
impl<'de> serde::Deserialize<'de> for hosted_zone::Visibility {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["VISIBILITY_UNSPECIFIED", "PUBLIC", "PRIVATE"];
        struct GeneratedVisitor;
        impl serde::de::Visitor<'_> for GeneratedVisitor {
            type Value = hosted_zone::Visibility;
            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(hosted_zone::Visibility::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(hosted_zone::Visibility::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 {
                    "VISIBILITY_UNSPECIFIED" => Ok(hosted_zone::Visibility::Unspecified),
                    "PUBLIC" => Ok(hosted_zone::Visibility::Public),
                    "PRIVATE" => Ok(hosted_zone::Visibility::Private),
                    _ => Ok(hosted_zone::Visibility::default()),
                }
            }
        }
        deserializer.deserialize_any(GeneratedVisitor)
    }
}
impl serde::Serialize for ListHostedZonesRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.parent.is_empty() {
            len += 1;
        }
        if self.page_size != 0 {
            len += 1;
        }
        if !self.page_token.is_empty() {
            len += 1;
        }
        if !self.dns_name.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.dns.v1beta1.ListHostedZonesRequest", len)?;
        if !self.parent.is_empty() {
            struct_ser.serialize_field("parent", &self.parent)?;
        }
        if self.page_size != 0 {
            struct_ser.serialize_field("pageSize", &self.page_size)?;
        }
        if !self.page_token.is_empty() {
            struct_ser.serialize_field("pageToken", &self.page_token)?;
        }
        if !self.dns_name.is_empty() {
            struct_ser.serialize_field("dnsName", &self.dns_name)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ListHostedZonesRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "parent",
            "page_size",
            "pageSize",
            "page_token",
            "pageToken",
            "dns_name",
            "dnsName",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Parent,
            PageSize,
            PageToken,
            DnsName,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "parent" => Ok(GeneratedField::Parent),
                            "pageSize" | "page_size" => Ok(GeneratedField::PageSize),
                            "pageToken" | "page_token" => Ok(GeneratedField::PageToken),
                            "dnsName" | "dns_name" => Ok(GeneratedField::DnsName),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = ListHostedZonesRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.dns.v1beta1.ListHostedZonesRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListHostedZonesRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut parent__ = None;
                let mut page_size__ = None;
                let mut page_token__ = None;
                let mut dns_name__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Parent => {
                            if parent__.is_some() {
                                return Err(serde::de::Error::duplicate_field("parent"));
                            }
                            parent__ = Some(map_.next_value()?);
                        }
                        GeneratedField::PageSize => {
                            if page_size__.is_some() {
                                return Err(serde::de::Error::duplicate_field("pageSize"));
                            }
                            page_size__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::PageToken => {
                            if page_token__.is_some() {
                                return Err(serde::de::Error::duplicate_field("pageToken"));
                            }
                            page_token__ = Some(map_.next_value()?);
                        }
                        GeneratedField::DnsName => {
                            if dns_name__.is_some() {
                                return Err(serde::de::Error::duplicate_field("dnsName"));
                            }
                            dns_name__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(ListHostedZonesRequest {
                    parent: parent__.unwrap_or_default(),
                    page_size: page_size__.unwrap_or_default(),
                    page_token: page_token__.unwrap_or_default(),
                    dns_name: dns_name__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.dns.v1beta1.ListHostedZonesRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListHostedZonesResponse {
    #[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.hosted_zones.is_empty() {
            len += 1;
        }
        if !self.next_page_token.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.dns.v1beta1.ListHostedZonesResponse", len)?;
        if !self.hosted_zones.is_empty() {
            struct_ser.serialize_field("hostedZones", &self.hosted_zones)?;
        }
        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 ListHostedZonesResponse {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "hosted_zones",
            "hostedZones",
            "next_page_token",
            "nextPageToken",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            HostedZones,
            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 {
                            "hostedZones" | "hosted_zones" => {
                                Ok(GeneratedField::HostedZones)
                            }
                            "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 = ListHostedZonesResponse;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.dns.v1beta1.ListHostedZonesResponse")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListHostedZonesResponse, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut hosted_zones__ = None;
                let mut next_page_token__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::HostedZones => {
                            if hosted_zones__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("hostedZones"),
                                );
                            }
                            hosted_zones__ = 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(ListHostedZonesResponse {
                    hosted_zones: hosted_zones__.unwrap_or_default(),
                    next_page_token: next_page_token__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.dns.v1beta1.ListHostedZonesResponse",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListRecordSetsRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.parent.is_empty() {
            len += 1;
        }
        if self.page_size != 0 {
            len += 1;
        }
        if !self.page_token.is_empty() {
            len += 1;
        }
        if !self.dns_name.is_empty() {
            len += 1;
        }
        if self.r#type != 0 {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.dns.v1beta1.ListRecordSetsRequest", len)?;
        if !self.parent.is_empty() {
            struct_ser.serialize_field("parent", &self.parent)?;
        }
        if self.page_size != 0 {
            struct_ser.serialize_field("pageSize", &self.page_size)?;
        }
        if !self.page_token.is_empty() {
            struct_ser.serialize_field("pageToken", &self.page_token)?;
        }
        if !self.dns_name.is_empty() {
            struct_ser.serialize_field("dnsName", &self.dns_name)?;
        }
        if self.r#type != 0 {
            let v = record_set::Type::try_from(self.r#type)
                .map_err(|_| serde::ser::Error::custom(
                    format!("Invalid variant {}", self.r#type),
                ))?;
            struct_ser.serialize_field("type", &v)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ListRecordSetsRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "parent",
            "page_size",
            "pageSize",
            "page_token",
            "pageToken",
            "dns_name",
            "dnsName",
            "type",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Parent,
            PageSize,
            PageToken,
            DnsName,
            Type,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "parent" => Ok(GeneratedField::Parent),
                            "pageSize" | "page_size" => Ok(GeneratedField::PageSize),
                            "pageToken" | "page_token" => Ok(GeneratedField::PageToken),
                            "dnsName" | "dns_name" => Ok(GeneratedField::DnsName),
                            "type" => Ok(GeneratedField::Type),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = ListRecordSetsRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.dns.v1beta1.ListRecordSetsRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListRecordSetsRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut parent__ = None;
                let mut page_size__ = None;
                let mut page_token__ = None;
                let mut dns_name__ = None;
                let mut r#type__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Parent => {
                            if parent__.is_some() {
                                return Err(serde::de::Error::duplicate_field("parent"));
                            }
                            parent__ = Some(map_.next_value()?);
                        }
                        GeneratedField::PageSize => {
                            if page_size__.is_some() {
                                return Err(serde::de::Error::duplicate_field("pageSize"));
                            }
                            page_size__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::PageToken => {
                            if page_token__.is_some() {
                                return Err(serde::de::Error::duplicate_field("pageToken"));
                            }
                            page_token__ = Some(map_.next_value()?);
                        }
                        GeneratedField::DnsName => {
                            if dns_name__.is_some() {
                                return Err(serde::de::Error::duplicate_field("dnsName"));
                            }
                            dns_name__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Type => {
                            if r#type__.is_some() {
                                return Err(serde::de::Error::duplicate_field("type"));
                            }
                            r#type__ = Some(
                                map_.next_value::<record_set::Type>()? as i32,
                            );
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(ListRecordSetsRequest {
                    parent: parent__.unwrap_or_default(),
                    page_size: page_size__.unwrap_or_default(),
                    page_token: page_token__.unwrap_or_default(),
                    dns_name: dns_name__.unwrap_or_default(),
                    r#type: r#type__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.dns.v1beta1.ListRecordSetsRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListRecordSetsResponse {
    #[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.record_sets.is_empty() {
            len += 1;
        }
        if !self.next_page_token.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.dns.v1beta1.ListRecordSetsResponse", len)?;
        if !self.record_sets.is_empty() {
            struct_ser.serialize_field("recordSets", &self.record_sets)?;
        }
        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 ListRecordSetsResponse {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "record_sets",
            "recordSets",
            "next_page_token",
            "nextPageToken",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            RecordSets,
            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 {
                            "recordSets" | "record_sets" => {
                                Ok(GeneratedField::RecordSets)
                            }
                            "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 = ListRecordSetsResponse;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.dns.v1beta1.ListRecordSetsResponse")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListRecordSetsResponse, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut record_sets__ = None;
                let mut next_page_token__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::RecordSets => {
                            if record_sets__.is_some() {
                                return Err(serde::de::Error::duplicate_field("recordSets"));
                            }
                            record_sets__ = 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(ListRecordSetsResponse {
                    record_sets: record_sets__.unwrap_or_default(),
                    next_page_token: next_page_token__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.dns.v1beta1.ListRecordSetsResponse",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListVpcAttachmentsRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.parent.is_empty() {
            len += 1;
        }
        if self.page_size != 0 {
            len += 1;
        }
        if !self.page_token.is_empty() {
            len += 1;
        }
        if !self.vpc.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.dns.v1beta1.ListVpcAttachmentsRequest", len)?;
        if !self.parent.is_empty() {
            struct_ser.serialize_field("parent", &self.parent)?;
        }
        if self.page_size != 0 {
            struct_ser.serialize_field("pageSize", &self.page_size)?;
        }
        if !self.page_token.is_empty() {
            struct_ser.serialize_field("pageToken", &self.page_token)?;
        }
        if !self.vpc.is_empty() {
            struct_ser.serialize_field("vpc", &self.vpc)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ListVpcAttachmentsRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "parent",
            "page_size",
            "pageSize",
            "page_token",
            "pageToken",
            "vpc",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Parent,
            PageSize,
            PageToken,
            Vpc,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "parent" => Ok(GeneratedField::Parent),
                            "pageSize" | "page_size" => Ok(GeneratedField::PageSize),
                            "pageToken" | "page_token" => Ok(GeneratedField::PageToken),
                            "vpc" => Ok(GeneratedField::Vpc),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = ListVpcAttachmentsRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.dns.v1beta1.ListVpcAttachmentsRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListVpcAttachmentsRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut parent__ = None;
                let mut page_size__ = None;
                let mut page_token__ = None;
                let mut vpc__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Parent => {
                            if parent__.is_some() {
                                return Err(serde::de::Error::duplicate_field("parent"));
                            }
                            parent__ = Some(map_.next_value()?);
                        }
                        GeneratedField::PageSize => {
                            if page_size__.is_some() {
                                return Err(serde::de::Error::duplicate_field("pageSize"));
                            }
                            page_size__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::PageToken => {
                            if page_token__.is_some() {
                                return Err(serde::de::Error::duplicate_field("pageToken"));
                            }
                            page_token__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Vpc => {
                            if vpc__.is_some() {
                                return Err(serde::de::Error::duplicate_field("vpc"));
                            }
                            vpc__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(ListVpcAttachmentsRequest {
                    parent: parent__.unwrap_or_default(),
                    page_size: page_size__.unwrap_or_default(),
                    page_token: page_token__.unwrap_or_default(),
                    vpc: vpc__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.dns.v1beta1.ListVpcAttachmentsRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListVpcAttachmentsResponse {
    #[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.vpc_attachments.is_empty() {
            len += 1;
        }
        if !self.next_page_token.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.dns.v1beta1.ListVpcAttachmentsResponse",
                len,
            )?;
        if !self.vpc_attachments.is_empty() {
            struct_ser.serialize_field("vpcAttachments", &self.vpc_attachments)?;
        }
        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 ListVpcAttachmentsResponse {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "vpc_attachments",
            "vpcAttachments",
            "next_page_token",
            "nextPageToken",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            VpcAttachments,
            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 {
                            "vpcAttachments" | "vpc_attachments" => {
                                Ok(GeneratedField::VpcAttachments)
                            }
                            "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 = ListVpcAttachmentsResponse;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.dns.v1beta1.ListVpcAttachmentsResponse",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListVpcAttachmentsResponse, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut vpc_attachments__ = None;
                let mut next_page_token__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::VpcAttachments => {
                            if vpc_attachments__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("vpcAttachments"),
                                );
                            }
                            vpc_attachments__ = 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(ListVpcAttachmentsResponse {
                    vpc_attachments: vpc_attachments__.unwrap_or_default(),
                    next_page_token: next_page_token__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.dns.v1beta1.ListVpcAttachmentsResponse",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for OwnershipChallenge {
    #[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.dns_name.is_empty() {
            len += 1;
        }
        if !self.token.is_empty() {
            len += 1;
        }
        if self.expire_time.is_some() {
            len += 1;
        }
        if self.verify_time.is_some() {
            len += 1;
        }
        if self.suspend_time.is_some() {
            len += 1;
        }
        if self.suspension_reason != 0 {
            len += 1;
        }
        if self.last_check != 0 {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.dns.v1beta1.OwnershipChallenge", len)?;
        if !self.dns_name.is_empty() {
            struct_ser.serialize_field("dnsName", &self.dns_name)?;
        }
        if !self.token.is_empty() {
            struct_ser.serialize_field("token", &self.token)?;
        }
        if let Some(v) = self.expire_time.as_ref() {
            struct_ser.serialize_field("expireTime", v)?;
        }
        if let Some(v) = self.verify_time.as_ref() {
            struct_ser.serialize_field("verifyTime", v)?;
        }
        if let Some(v) = self.suspend_time.as_ref() {
            struct_ser.serialize_field("suspendTime", v)?;
        }
        if self.suspension_reason != 0 {
            let v = ownership_challenge::SuspensionReason::try_from(
                    self.suspension_reason,
                )
                .map_err(|_| serde::ser::Error::custom(
                    format!("Invalid variant {}", self.suspension_reason),
                ))?;
            struct_ser.serialize_field("suspensionReason", &v)?;
        }
        if self.last_check != 0 {
            let v = ownership_challenge::CheckOutcome::try_from(self.last_check)
                .map_err(|_| serde::ser::Error::custom(
                    format!("Invalid variant {}", self.last_check),
                ))?;
            struct_ser.serialize_field("lastCheck", &v)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for OwnershipChallenge {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "dns_name",
            "dnsName",
            "token",
            "expire_time",
            "expireTime",
            "verify_time",
            "verifyTime",
            "suspend_time",
            "suspendTime",
            "suspension_reason",
            "suspensionReason",
            "last_check",
            "lastCheck",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            DnsName,
            Token,
            ExpireTime,
            VerifyTime,
            SuspendTime,
            SuspensionReason,
            LastCheck,
            __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 {
                            "dnsName" | "dns_name" => Ok(GeneratedField::DnsName),
                            "token" => Ok(GeneratedField::Token),
                            "expireTime" | "expire_time" => {
                                Ok(GeneratedField::ExpireTime)
                            }
                            "verifyTime" | "verify_time" => {
                                Ok(GeneratedField::VerifyTime)
                            }
                            "suspendTime" | "suspend_time" => {
                                Ok(GeneratedField::SuspendTime)
                            }
                            "suspensionReason" | "suspension_reason" => {
                                Ok(GeneratedField::SuspensionReason)
                            }
                            "lastCheck" | "last_check" => Ok(GeneratedField::LastCheck),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = OwnershipChallenge;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.dns.v1beta1.OwnershipChallenge")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<OwnershipChallenge, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut dns_name__ = None;
                let mut token__ = None;
                let mut expire_time__ = None;
                let mut verify_time__ = None;
                let mut suspend_time__ = None;
                let mut suspension_reason__ = None;
                let mut last_check__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::DnsName => {
                            if dns_name__.is_some() {
                                return Err(serde::de::Error::duplicate_field("dnsName"));
                            }
                            dns_name__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Token => {
                            if token__.is_some() {
                                return Err(serde::de::Error::duplicate_field("token"));
                            }
                            token__ = Some(map_.next_value()?);
                        }
                        GeneratedField::ExpireTime => {
                            if expire_time__.is_some() {
                                return Err(serde::de::Error::duplicate_field("expireTime"));
                            }
                            expire_time__ = map_.next_value()?;
                        }
                        GeneratedField::VerifyTime => {
                            if verify_time__.is_some() {
                                return Err(serde::de::Error::duplicate_field("verifyTime"));
                            }
                            verify_time__ = map_.next_value()?;
                        }
                        GeneratedField::SuspendTime => {
                            if suspend_time__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("suspendTime"),
                                );
                            }
                            suspend_time__ = map_.next_value()?;
                        }
                        GeneratedField::SuspensionReason => {
                            if suspension_reason__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("suspensionReason"),
                                );
                            }
                            suspension_reason__ = Some(
                                map_.next_value::<ownership_challenge::SuspensionReason>()?
                                    as i32,
                            );
                        }
                        GeneratedField::LastCheck => {
                            if last_check__.is_some() {
                                return Err(serde::de::Error::duplicate_field("lastCheck"));
                            }
                            last_check__ = Some(
                                map_.next_value::<ownership_challenge::CheckOutcome>()?
                                    as i32,
                            );
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(OwnershipChallenge {
                    dns_name: dns_name__.unwrap_or_default(),
                    token: token__.unwrap_or_default(),
                    expire_time: expire_time__,
                    verify_time: verify_time__,
                    suspend_time: suspend_time__,
                    suspension_reason: suspension_reason__.unwrap_or_default(),
                    last_check: last_check__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.dns.v1beta1.OwnershipChallenge",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ownership_challenge::CheckOutcome {
    #[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 => "CHECK_OUTCOME_UNSPECIFIED",
            Self::Ok => "OK",
            Self::NotFound => "NOT_FOUND",
            Self::NameHeld => "NAME_HELD",
        };
        serializer.serialize_str(variant)
    }
}
impl<'de> serde::Deserialize<'de> for ownership_challenge::CheckOutcome {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "CHECK_OUTCOME_UNSPECIFIED",
            "OK",
            "NOT_FOUND",
            "NAME_HELD",
        ];
        struct GeneratedVisitor;
        impl serde::de::Visitor<'_> for GeneratedVisitor {
            type Value = ownership_challenge::CheckOutcome;
            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(
                                ownership_challenge::CheckOutcome::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(
                                ownership_challenge::CheckOutcome::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 {
                    "CHECK_OUTCOME_UNSPECIFIED" => {
                        Ok(ownership_challenge::CheckOutcome::Unspecified)
                    }
                    "OK" => Ok(ownership_challenge::CheckOutcome::Ok),
                    "NOT_FOUND" => Ok(ownership_challenge::CheckOutcome::NotFound),
                    "NAME_HELD" => Ok(ownership_challenge::CheckOutcome::NameHeld),
                    _ => Ok(ownership_challenge::CheckOutcome::default()),
                }
            }
        }
        deserializer.deserialize_any(GeneratedVisitor)
    }
}
impl serde::Serialize for ownership_challenge::SuspensionReason {
    #[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 => "SUSPENSION_REASON_UNSPECIFIED",
            Self::ChallengeLost => "CHALLENGE_LOST",
        };
        serializer.serialize_str(variant)
    }
}
impl<'de> serde::Deserialize<'de> for ownership_challenge::SuspensionReason {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["SUSPENSION_REASON_UNSPECIFIED", "CHALLENGE_LOST"];
        struct GeneratedVisitor;
        impl serde::de::Visitor<'_> for GeneratedVisitor {
            type Value = ownership_challenge::SuspensionReason;
            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(
                                ownership_challenge::SuspensionReason::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(
                                ownership_challenge::SuspensionReason::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 {
                    "SUSPENSION_REASON_UNSPECIFIED" => {
                        Ok(ownership_challenge::SuspensionReason::Unspecified)
                    }
                    "CHALLENGE_LOST" => {
                        Ok(ownership_challenge::SuspensionReason::ChallengeLost)
                    }
                    _ => Ok(ownership_challenge::SuspensionReason::default()),
                }
            }
        }
        deserializer.deserialize_any(GeneratedVisitor)
    }
}
impl serde::Serialize for RecordSet {
    #[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.dns_name.is_empty() {
            len += 1;
        }
        if self.r#type != 0 {
            len += 1;
        }
        if self.ttl.is_some() {
            len += 1;
        }
        if self.create_time.is_some() {
            len += 1;
        }
        if self.update_time.is_some() {
            len += 1;
        }
        if self.data.is_some() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.dns.v1beta1.RecordSet", 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.dns_name.is_empty() {
            struct_ser.serialize_field("dnsName", &self.dns_name)?;
        }
        if self.r#type != 0 {
            let v = record_set::Type::try_from(self.r#type)
                .map_err(|_| serde::ser::Error::custom(
                    format!("Invalid variant {}", self.r#type),
                ))?;
            struct_ser.serialize_field("type", &v)?;
        }
        if let Some(v) = self.ttl.as_ref() {
            struct_ser.serialize_field("ttl", v)?;
        }
        if let Some(v) = self.create_time.as_ref() {
            struct_ser.serialize_field("createTime", v)?;
        }
        if let Some(v) = self.update_time.as_ref() {
            struct_ser.serialize_field("updateTime", v)?;
        }
        if let Some(v) = self.data.as_ref() {
            match v {
                record_set::Data::Basic(v) => {
                    struct_ser.serialize_field("basic", v)?;
                }
                record_set::Data::Alias(v) => {
                    struct_ser.serialize_field("alias", v)?;
                }
            }
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for RecordSet {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "name",
            "urn",
            "dns_name",
            "dnsName",
            "type",
            "ttl",
            "create_time",
            "createTime",
            "update_time",
            "updateTime",
            "basic",
            "alias",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            Urn,
            DnsName,
            Type,
            Ttl,
            CreateTime,
            UpdateTime,
            Basic,
            Alias,
            __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),
                            "dnsName" | "dns_name" => Ok(GeneratedField::DnsName),
                            "type" => Ok(GeneratedField::Type),
                            "ttl" => Ok(GeneratedField::Ttl),
                            "createTime" | "create_time" => {
                                Ok(GeneratedField::CreateTime)
                            }
                            "updateTime" | "update_time" => {
                                Ok(GeneratedField::UpdateTime)
                            }
                            "basic" => Ok(GeneratedField::Basic),
                            "alias" => Ok(GeneratedField::Alias),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = RecordSet;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.dns.v1beta1.RecordSet")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<RecordSet, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                let mut urn__ = None;
                let mut dns_name__ = None;
                let mut r#type__ = None;
                let mut ttl__ = None;
                let mut create_time__ = None;
                let mut update_time__ = None;
                let mut data__ = 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::DnsName => {
                            if dns_name__.is_some() {
                                return Err(serde::de::Error::duplicate_field("dnsName"));
                            }
                            dns_name__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Type => {
                            if r#type__.is_some() {
                                return Err(serde::de::Error::duplicate_field("type"));
                            }
                            r#type__ = Some(
                                map_.next_value::<record_set::Type>()? as i32,
                            );
                        }
                        GeneratedField::Ttl => {
                            if ttl__.is_some() {
                                return Err(serde::de::Error::duplicate_field("ttl"));
                            }
                            ttl__ = map_.next_value()?;
                        }
                        GeneratedField::CreateTime => {
                            if create_time__.is_some() {
                                return Err(serde::de::Error::duplicate_field("createTime"));
                            }
                            create_time__ = map_.next_value()?;
                        }
                        GeneratedField::UpdateTime => {
                            if update_time__.is_some() {
                                return Err(serde::de::Error::duplicate_field("updateTime"));
                            }
                            update_time__ = map_.next_value()?;
                        }
                        GeneratedField::Basic => {
                            if data__.is_some() {
                                return Err(serde::de::Error::duplicate_field("basic"));
                            }
                            data__ = map_
                                .next_value::<::std::option::Option<_>>()?
                                .map(record_set::Data::Basic);
                        }
                        GeneratedField::Alias => {
                            if data__.is_some() {
                                return Err(serde::de::Error::duplicate_field("alias"));
                            }
                            data__ = map_
                                .next_value::<::std::option::Option<_>>()?
                                .map(record_set::Data::Alias);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(RecordSet {
                    name: name__.unwrap_or_default(),
                    urn: urn__.unwrap_or_default(),
                    dns_name: dns_name__.unwrap_or_default(),
                    r#type: r#type__.unwrap_or_default(),
                    ttl: ttl__,
                    create_time: create_time__,
                    update_time: update_time__,
                    data: data__,
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.dns.v1beta1.RecordSet",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for record_set::Type {
    #[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 => "TYPE_UNSPECIFIED",
            Self::A => "A",
            Self::Aaaa => "AAAA",
            Self::Cname => "CNAME",
            Self::Txt => "TXT",
            Self::Mx => "MX",
            Self::Srv => "SRV",
            Self::Caa => "CAA",
        };
        serializer.serialize_str(variant)
    }
}
impl<'de> serde::Deserialize<'de> for record_set::Type {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "TYPE_UNSPECIFIED",
            "A",
            "AAAA",
            "CNAME",
            "TXT",
            "MX",
            "SRV",
            "CAA",
        ];
        struct GeneratedVisitor;
        impl serde::de::Visitor<'_> for GeneratedVisitor {
            type Value = record_set::Type;
            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(record_set::Type::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(record_set::Type::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 {
                    "TYPE_UNSPECIFIED" => Ok(record_set::Type::Unspecified),
                    "A" => Ok(record_set::Type::A),
                    "AAAA" => Ok(record_set::Type::Aaaa),
                    "CNAME" => Ok(record_set::Type::Cname),
                    "TXT" => Ok(record_set::Type::Txt),
                    "MX" => Ok(record_set::Type::Mx),
                    "SRV" => Ok(record_set::Type::Srv),
                    "CAA" => Ok(record_set::Type::Caa),
                    _ => Ok(record_set::Type::default()),
                }
            }
        }
        deserializer.deserialize_any(GeneratedVisitor)
    }
}
impl serde::Serialize for RecordSetUpdate {
    #[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.record_set.is_some() {
            len += 1;
        }
        if self.update_mask.is_some() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.dns.v1beta1.RecordSetUpdate", len)?;
        if let Some(v) = self.record_set.as_ref() {
            struct_ser.serialize_field("recordSet", 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 RecordSetUpdate {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "record_set",
            "recordSet",
            "update_mask",
            "updateMask",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            RecordSet,
            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 {
                            "recordSet" | "record_set" => Ok(GeneratedField::RecordSet),
                            "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 = RecordSetUpdate;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.dns.v1beta1.RecordSetUpdate")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<RecordSetUpdate, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut record_set__ = None;
                let mut update_mask__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::RecordSet => {
                            if record_set__.is_some() {
                                return Err(serde::de::Error::duplicate_field("recordSet"));
                            }
                            record_set__ = 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(RecordSetUpdate {
                    record_set: record_set__,
                    update_mask: update_mask__,
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.dns.v1beta1.RecordSetUpdate",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for UpdateHostedZoneRequest {
    #[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.hosted_zone.is_some() {
            len += 1;
        }
        if self.update_mask.is_some() {
            len += 1;
        }
        if !self.request_id.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.dns.v1beta1.UpdateHostedZoneRequest", len)?;
        if let Some(v) = self.hosted_zone.as_ref() {
            struct_ser.serialize_field("hostedZone", v)?;
        }
        if let Some(v) = self.update_mask.as_ref() {
            struct_ser.serialize_field("updateMask", v)?;
        }
        if !self.request_id.is_empty() {
            struct_ser.serialize_field("requestId", &self.request_id)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for UpdateHostedZoneRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "hosted_zone",
            "hostedZone",
            "update_mask",
            "updateMask",
            "request_id",
            "requestId",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            HostedZone,
            UpdateMask,
            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 {
                            "hostedZone" | "hosted_zone" => {
                                Ok(GeneratedField::HostedZone)
                            }
                            "updateMask" | "update_mask" => {
                                Ok(GeneratedField::UpdateMask)
                            }
                            "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 = UpdateHostedZoneRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.dns.v1beta1.UpdateHostedZoneRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<UpdateHostedZoneRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut hosted_zone__ = None;
                let mut update_mask__ = None;
                let mut request_id__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::HostedZone => {
                            if hosted_zone__.is_some() {
                                return Err(serde::de::Error::duplicate_field("hostedZone"));
                            }
                            hosted_zone__ = map_.next_value()?;
                        }
                        GeneratedField::UpdateMask => {
                            if update_mask__.is_some() {
                                return Err(serde::de::Error::duplicate_field("updateMask"));
                            }
                            update_mask__ = 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(UpdateHostedZoneRequest {
                    hosted_zone: hosted_zone__,
                    update_mask: update_mask__,
                    request_id: request_id__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.dns.v1beta1.UpdateHostedZoneRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for UpdateRecordSetRequest {
    #[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.record_set.is_some() {
            len += 1;
        }
        if self.update_mask.is_some() {
            len += 1;
        }
        if !self.request_id.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.dns.v1beta1.UpdateRecordSetRequest", len)?;
        if let Some(v) = self.record_set.as_ref() {
            struct_ser.serialize_field("recordSet", v)?;
        }
        if let Some(v) = self.update_mask.as_ref() {
            struct_ser.serialize_field("updateMask", v)?;
        }
        if !self.request_id.is_empty() {
            struct_ser.serialize_field("requestId", &self.request_id)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for UpdateRecordSetRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "record_set",
            "recordSet",
            "update_mask",
            "updateMask",
            "request_id",
            "requestId",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            RecordSet,
            UpdateMask,
            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 {
                            "recordSet" | "record_set" => Ok(GeneratedField::RecordSet),
                            "updateMask" | "update_mask" => {
                                Ok(GeneratedField::UpdateMask)
                            }
                            "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 = UpdateRecordSetRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.dns.v1beta1.UpdateRecordSetRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<UpdateRecordSetRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut record_set__ = None;
                let mut update_mask__ = None;
                let mut request_id__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::RecordSet => {
                            if record_set__.is_some() {
                                return Err(serde::de::Error::duplicate_field("recordSet"));
                            }
                            record_set__ = map_.next_value()?;
                        }
                        GeneratedField::UpdateMask => {
                            if update_mask__.is_some() {
                                return Err(serde::de::Error::duplicate_field("updateMask"));
                            }
                            update_mask__ = 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(UpdateRecordSetRequest {
                    record_set: record_set__,
                    update_mask: update_mask__,
                    request_id: request_id__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.dns.v1beta1.UpdateRecordSetRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for VerifyHostedZoneRequest {
    #[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.dns.v1beta1.VerifyHostedZoneRequest", len)?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for VerifyHostedZoneRequest {
    #[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 = VerifyHostedZoneRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.dns.v1beta1.VerifyHostedZoneRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<VerifyHostedZoneRequest, 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(VerifyHostedZoneRequest {
                    name: name__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.dns.v1beta1.VerifyHostedZoneRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for VpcAttachment {
    #[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.vpc.is_empty() {
            len += 1;
        }
        if self.create_time.is_some() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.dns.v1beta1.VpcAttachment", 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.vpc.is_empty() {
            struct_ser.serialize_field("vpc", &self.vpc)?;
        }
        if let Some(v) = self.create_time.as_ref() {
            struct_ser.serialize_field("createTime", v)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for VpcAttachment {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["name", "urn", "vpc", "create_time", "createTime"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            Urn,
            Vpc,
            CreateTime,
            __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),
                            "vpc" => Ok(GeneratedField::Vpc),
                            "createTime" | "create_time" => {
                                Ok(GeneratedField::CreateTime)
                            }
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = VpcAttachment;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.dns.v1beta1.VpcAttachment")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<VpcAttachment, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                let mut urn__ = None;
                let mut vpc__ = None;
                let mut create_time__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Name => {
                            if name__.is_some() {
                                return Err(serde::de::Error::duplicate_field("name"));
                            }
                            name__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Urn => {
                            if urn__.is_some() {
                                return Err(serde::de::Error::duplicate_field("urn"));
                            }
                            urn__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Vpc => {
                            if vpc__.is_some() {
                                return Err(serde::de::Error::duplicate_field("vpc"));
                            }
                            vpc__ = 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::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(VpcAttachment {
                    name: name__.unwrap_or_default(),
                    urn: urn__.unwrap_or_default(),
                    vpc: vpc__.unwrap_or_default(),
                    create_time: create_time__,
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.dns.v1beta1.VpcAttachment",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
/// Calls `HostedZoneService`.
///
/// Hosted zones: the domains a project's records are answered for.
///
/// A public zone holds its name only once it proves control of it: until
/// then it is `hosted_zone::State::PendingVerification`, and any number of zones of any
/// project may be pending for the same name. It proves control with a TXT
/// record at `_origin-challenge.{dns_name}` holding the zone's token,
/// answered by the name's current DNS. The first zone of a name to verify
/// becomes `hosted_zone::State::Active`, holds the name, and is answered from the platform's
/// name servers once the name is delegated to them; the others stay
/// pending. A zone that doesn't verify within its window is deleted with
/// its record sets. The platform checks pending zones on its own, more
/// rarely the longer they stay pending; `VerifyHostedZone` checks one now.
///
/// An active public zone is checked again every day. It keeps its name
/// while the name is delegated to the platform's name servers, or while the
/// token still answers at the name's other name servers. After several
/// checks in a row find the name delegated elsewhere without the token, it
/// is `hosted_zone::State::Suspended`: no longer answered, its record sets kept, and its name
/// free for another zone to verify. Verifying it again while its name is
/// free makes it active again.
///
/// A private zone is active from the start, and answers in the VPCs it is
/// attached to.
#[derive(Clone, Debug)]
pub struct HostedZoneClient {
    service: ::origincloud_core::Service,
}
impl HostedZoneClient {
    /// Returns a client of `HostedZoneService` that sends its calls through `client`.
    pub fn new(client: &::origincloud_core::Client) -> Self {
        Self {
            service: client.service("dns", 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 hosted zone.
    pub async fn get_hosted_zone(
        &self,
        request: GetHostedZoneRequest,
    ) -> ::core::result::Result<HostedZone, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "name",
            &request.name,
            "projects/*/hostedZones/*",
        )?;
        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 a project's hosted zones, oldest first.
    pub async fn list_hosted_zones(
        &self,
        request: ListHostedZonesRequest,
    ) -> ::core::result::Result<ListHostedZonesResponse, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "parent",
            &request.parent,
            "projects/*",
        )?;
        let query = ::origincloud_core::query(&request, &["parent"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::GET,
                format!("/v1beta1/{p0}/hostedZones"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Returns everything [`list_hosted_zones`](Self::list_hosted_zones) 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_hosted_zones(
        &self,
        request: ListHostedZonesRequest,
    ) -> ::origincloud_core::Pages<HostedZone> {
        let client = self.clone();
        ::origincloud_core::Pages::new(
            request,
            move |request: ListHostedZonesRequest| {
                let client = client.clone();
                async move {
                    let page = client.list_hosted_zones(request).await?;
                    Ok((page.hosted_zones, page.next_page_token))
                }
            },
            |request: &mut ListHostedZonesRequest, token: ::std::string::String| {
                request.page_token = token;
            },
        )
    }
    /// Creates a hosted zone, empty. A public zone starts
    /// `hosted_zone::State::PendingVerification`, with the token to publish in `challenge`; a
    /// private zone starts `hosted_zone::State::Active`. Refused with `BAD_REQUEST` for a name the
    /// platform keeps for itself, or once the project's or organization's
    /// quota of zones is used up, and with `PAYMENT_METHOD_REQUIRED` while the
    /// project has no valid billing.
    pub async fn create_hosted_zone(
        &self,
        mut request: CreateHostedZoneRequest,
    ) -> ::core::result::Result<HostedZone, ::origincloud_core::Error> {
        if request.request_id.is_empty() {
            request.request_id = ::origincloud_core::new_request_id();
        }
        let p0 = ::origincloud_core::path_value(
            "parent",
            &request.parent,
            "projects/*",
        )?;
        let body = ::origincloud_core::json_body(
            request.hosted_zone.as_ref().unwrap_or(&::core::default::Default::default()),
        )?;
        let query = ::origincloud_core::query(&request, &["parent", "hostedZone"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::POST,
                format!("/v1beta1/{p0}/hostedZones"),
            )
            .with_body(body)
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Changes a hosted zone's tags.
    pub async fn update_hosted_zone(
        &self,
        mut request: UpdateHostedZoneRequest,
    ) -> ::core::result::Result<HostedZone, ::origincloud_core::Error> {
        if request.request_id.is_empty() {
            request.request_id = ::origincloud_core::new_request_id();
        }
        let p0 = ::origincloud_core::path_value(
            "hostedZone.name",
            request.hosted_zone.as_ref().map_or("", |m| m.name.as_str()),
            "projects/*/hostedZones/*",
        )?;
        let body = ::origincloud_core::json_body(
            request.hosted_zone.as_ref().unwrap_or(&::core::default::Default::default()),
        )?;
        let query = ::origincloud_core::query(
            &request,
            &["hostedZone.name", "hostedZone"],
        )?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::PATCH,
                format!("/v1beta1/{p0}"),
            )
            .with_body(body)
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Deletes a hosted zone. Refused with `CONFLICT` while it holds record
    /// sets or, for a private zone, VPC attachments: delete them first.
    pub async fn delete_hosted_zone(
        &self,
        mut request: DeleteHostedZoneRequest,
    ) -> ::core::result::Result<
        ::origincloud_core::protobuf::Empty,
        ::origincloud_core::Error,
    > {
        if request.request_id.is_empty() {
            request.request_id = ::origincloud_core::new_request_id();
        }
        let p0 = ::origincloud_core::path_value(
            "name",
            &request.name,
            "projects/*/hostedZones/*",
        )?;
        let query = ::origincloud_core::query(&request, &["name"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::DELETE,
                format!("/v1beta1/{p0}"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Checks a public zone's challenge now, instead of waiting for the
    /// platform's next check, and returns the zone as it is then, with the
    /// check's outcome in `challenge.last_check`. A pending zone whose token
    /// answers becomes `hosted_zone::State::Active`, and so does a suspended one while its name is
    /// free; otherwise the zone stays as it was. A call within 30 seconds of
    /// the zone's last check answers with that check's outcome and asks the
    /// name's DNS nothing. Refused with `ownership_challenge::CheckOutcome::NotFound` once a pending zone's
    /// window has ended, which deleted it, and with `SERVICE_UNAVAILABLE`,
    /// retryable, when the name's DNS didn't answer in time or too many checks
    /// are under way. A private zone has no challenge, and is refused with
    /// `BAD_REQUEST`. Checking an active zone changes nothing, so a client may
    /// repeat the call.
    pub async fn verify_hosted_zone(
        &self,
        request: VerifyHostedZoneRequest,
    ) -> ::core::result::Result<HostedZone, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "name",
            &request.name,
            "projects/*/hostedZones/*",
        )?;
        let body = ::origincloud_core::json_body(&request)?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::POST,
                format!("/v1beta1/{p0}:verify"),
            )
            .with_body(body);
        self.service.call(call).await
    }
}
/// Calls `RecordSetService`.
///
/// Record sets: every record of one name and type in a hosted zone. A zone
/// holds one record set per name and type, whatever its kind. A CNAME is
/// alone at its name and never at the zone's apex. The apex's SOA and NS
/// records are the platform's, written from the zone's name servers; they
/// aren't record sets, and no NS record delegates a name below the apex.
///
/// A change is recorded when its method answers, and answered wherever the
/// zone is served. `BatchChangeRecordSets` makes several changes at once,
/// all or none.
#[derive(Clone, Debug)]
pub struct RecordSetClient {
    service: ::origincloud_core::Service,
}
impl RecordSetClient {
    /// Returns a client of `RecordSetService` that sends its calls through `client`.
    pub fn new(client: &::origincloud_core::Client) -> Self {
        Self {
            service: client.service("dns", 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 record set.
    pub async fn get_record_set(
        &self,
        request: GetRecordSetRequest,
    ) -> ::core::result::Result<RecordSet, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "name",
            &request.name,
            "projects/*/hostedZones/*/recordSets/*",
        )?;
        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 a zone's record sets by `dns_name`, then by `type`.
    pub async fn list_record_sets(
        &self,
        request: ListRecordSetsRequest,
    ) -> ::core::result::Result<ListRecordSetsResponse, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "parent",
            &request.parent,
            "projects/*/hostedZones/*",
        )?;
        let query = ::origincloud_core::query(&request, &["parent"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::GET,
                format!("/v1beta1/{p0}/recordSets"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Returns everything [`list_record_sets`](Self::list_record_sets) 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_record_sets(
        &self,
        request: ListRecordSetsRequest,
    ) -> ::origincloud_core::Pages<RecordSet> {
        let client = self.clone();
        ::origincloud_core::Pages::new(
            request,
            move |request: ListRecordSetsRequest| {
                let client = client.clone();
                async move {
                    let page = client.list_record_sets(request).await?;
                    Ok((page.record_sets, page.next_page_token))
                }
            },
            |request: &mut ListRecordSetsRequest, token: ::std::string::String| {
                request.page_token = token;
            },
        )
    }
    /// Creates a record set. Refused with `CONFLICT` when the zone holds a
    /// record set of that name and type, or when a CNAME would share its name.
    /// Refused with `BAD_REQUEST` for a name outside the zone, a value its
    /// type doesn't take, an alias to a Floating IP outside the zone's
    /// project, or once the project's or organization's quota of record sets
    /// is used up. An alias to a Floating IP that was created moments ago may
    /// be refused with `SERVICE_UNAVAILABLE`, retryable.
    pub async fn create_record_set(
        &self,
        mut request: CreateRecordSetRequest,
    ) -> ::core::result::Result<RecordSet, ::origincloud_core::Error> {
        if request.request_id.is_empty() {
            request.request_id = ::origincloud_core::new_request_id();
        }
        let p0 = ::origincloud_core::path_value(
            "parent",
            &request.parent,
            "projects/*/hostedZones/*",
        )?;
        let body = ::origincloud_core::json_body(
            request.record_set.as_ref().unwrap_or(&::core::default::Default::default()),
        )?;
        let query = ::origincloud_core::query(&request, &["parent", "recordSet"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::POST,
                format!("/v1beta1/{p0}/recordSets"),
            )
            .with_body(body)
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Replaces a record set's TTL or what it answers with: `ttl`, `basic` or
    /// `alias`, or `*`. Naming one kind in `update_mask` replaces the kind the
    /// record set had. With `*`, a TTL left out keeps the record set's; naming
    /// `ttl` without one sets the default, 300 seconds. Its name and type
    /// stay; another type is a new record set.
    pub async fn update_record_set(
        &self,
        mut request: UpdateRecordSetRequest,
    ) -> ::core::result::Result<RecordSet, ::origincloud_core::Error> {
        if request.request_id.is_empty() {
            request.request_id = ::origincloud_core::new_request_id();
        }
        let p0 = ::origincloud_core::path_value(
            "recordSet.name",
            request.record_set.as_ref().map_or("", |m| m.name.as_str()),
            "projects/*/hostedZones/*/recordSets/*",
        )?;
        let body = ::origincloud_core::json_body(
            request.record_set.as_ref().unwrap_or(&::core::default::Default::default()),
        )?;
        let query = ::origincloud_core::query(
            &request,
            &["recordSet.name", "recordSet"],
        )?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::PATCH,
                format!("/v1beta1/{p0}"),
            )
            .with_body(body)
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Deletes a record set.
    pub async fn delete_record_set(
        &self,
        mut request: DeleteRecordSetRequest,
    ) -> ::core::result::Result<
        ::origincloud_core::protobuf::Empty,
        ::origincloud_core::Error,
    > {
        if request.request_id.is_empty() {
            request.request_id = ::origincloud_core::new_request_id();
        }
        let p0 = ::origincloud_core::path_value(
            "name",
            &request.name,
            "projects/*/hostedZones/*/recordSets/*",
        )?;
        let query = ::origincloud_core::query(&request, &["name"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::DELETE,
                format!("/v1beta1/{p0}"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Deletes, replaces and creates record sets of one zone together, all or
    /// none. The zone is checked as the changes leave it, not after each
    /// change, so a CNAME may take the place of the A record set it replaces
    /// in one call. A batch makes 1 to 1000 changes, and names a record set
    /// once at most across `deletions` and `updates`. Each change is refused
    /// as its own method would refuse it, naming the change; then none is
    /// made.
    pub async fn batch_change_record_sets(
        &self,
        mut request: BatchChangeRecordSetsRequest,
    ) -> ::core::result::Result<
        BatchChangeRecordSetsResponse,
        ::origincloud_core::Error,
    > {
        if request.request_id.is_empty() {
            request.request_id = ::origincloud_core::new_request_id();
        }
        let p0 = ::origincloud_core::path_value(
            "parent",
            &request.parent,
            "projects/*/hostedZones/*",
        )?;
        let body = ::origincloud_core::json_body(&request)?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::POST,
                format!("/v1beta1/{p0}/recordSets:batchChange"),
            )
            .with_body(body)
            .idempotent();
        self.service.call(call).await
    }
}
/// Calls `VpcAttachmentService`.
///
/// VPC attachments: the VPCs a private zone answers in. Each attachment
/// makes the zone's names resolve from every instance in one VPC, in every
/// zone the VPC spans, and from no other VPC. A private zone attaches only
/// to VPCs of its own project, and a VPC holds at most one attached zone of
/// a name. An attachment's id is the VPC's id, so a client that knows the
/// zone and the VPC names the attachment without listing. Deleting a VPC
/// deletes its attachments. Attaching a public zone is refused: it answers on
/// the internet, in every VPC alike.
#[derive(Clone, Debug)]
pub struct VpcAttachmentClient {
    service: ::origincloud_core::Service,
}
impl VpcAttachmentClient {
    /// Returns a client of `VpcAttachmentService` that sends its calls through `client`.
    pub fn new(client: &::origincloud_core::Client) -> Self {
        Self {
            service: client.service("dns", 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 VPC attachment.
    pub async fn get_vpc_attachment(
        &self,
        request: GetVpcAttachmentRequest,
    ) -> ::core::result::Result<VpcAttachment, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "name",
            &request.name,
            "projects/*/hostedZones/*/vpcAttachments/*",
        )?;
        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 a private zone's VPC attachments, oldest first. With `-` for the
    /// zone, lists every zone's in the project, which with `vpc` finds the
    /// zones attached to a VPC.
    pub async fn list_vpc_attachments(
        &self,
        request: ListVpcAttachmentsRequest,
    ) -> ::core::result::Result<ListVpcAttachmentsResponse, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "parent",
            &request.parent,
            "projects/*/hostedZones/*",
        )?;
        let query = ::origincloud_core::query(&request, &["parent"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::GET,
                format!("/v1beta1/{p0}/vpcAttachments"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Returns everything [`list_vpc_attachments`](Self::list_vpc_attachments) 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_vpc_attachments(
        &self,
        request: ListVpcAttachmentsRequest,
    ) -> ::origincloud_core::Pages<VpcAttachment> {
        let client = self.clone();
        ::origincloud_core::Pages::new(
            request,
            move |request: ListVpcAttachmentsRequest| {
                let client = client.clone();
                async move {
                    let page = client.list_vpc_attachments(request).await?;
                    Ok((page.vpc_attachments, page.next_page_token))
                }
            },
            |request: &mut ListVpcAttachmentsRequest, token: ::std::string::String| {
                request.page_token = token;
            },
        )
    }
    /// Attaches a private zone to a VPC of the zone's project. Refused with
    /// `BAD_REQUEST` for a public zone, or for a VPC that isn't in the zone's
    /// project, with the same words whichever project it is in. Refused with
    /// `CONFLICT` when the VPC holds an attached zone of the same name. A VPC
    /// created moments ago may be refused with `SERVICE_UNAVAILABLE`,
    /// retryable. The VPC's instances resolve the zone's names once the VPC's
    /// hosts serve the zone.
    pub async fn create_vpc_attachment(
        &self,
        mut request: CreateVpcAttachmentRequest,
    ) -> ::core::result::Result<VpcAttachment, ::origincloud_core::Error> {
        if request.request_id.is_empty() {
            request.request_id = ::origincloud_core::new_request_id();
        }
        let p0 = ::origincloud_core::path_value(
            "parent",
            &request.parent,
            "projects/*/hostedZones/*",
        )?;
        let body = ::origincloud_core::json_body(
            request
                .vpc_attachment
                .as_ref()
                .unwrap_or(&::core::default::Default::default()),
        )?;
        let query = ::origincloud_core::query(&request, &["parent", "vpcAttachment"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::POST,
                format!("/v1beta1/{p0}/vpcAttachments"),
            )
            .with_body(body)
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Detaches a private zone from a VPC. The VPC's instances stop resolving
    /// the zone's names once the VPC's hosts drop the zone.
    pub async fn delete_vpc_attachment(
        &self,
        mut request: DeleteVpcAttachmentRequest,
    ) -> ::core::result::Result<
        ::origincloud_core::protobuf::Empty,
        ::origincloud_core::Error,
    > {
        if request.request_id.is_empty() {
            request.request_id = ::origincloud_core::new_request_id();
        }
        let p0 = ::origincloud_core::path_value(
            "name",
            &request.name,
            "projects/*/hostedZones/*/vpcAttachments/*",
        )?;
        let query = ::origincloud_core::query(&request, &["name"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::DELETE,
                format!("/v1beta1/{p0}"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
}