origincloud_compute/generated/

origincloud.compute.v1beta1.rs

// Code generated by origincloud-sdk-generator. DO NOT EDIT.
// source: origincloud/compute/v1beta1/catalog.proto
// source: origincloud/compute/v1beta1/image.proto
// source: origincloud/compute/v1beta1/instance.proto
// source: origincloud/compute/v1beta1/key_pair.proto
// source: origincloud/compute/v1beta1/public_image.proto
// source: origincloud/compute/v1beta1/volume_attachment.proto

/// A size an instance is launched as.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct InstanceType {
    /// The type's resource name, `instanceTypes/gp1.core.2`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The name the console shows.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// The hardware kind, such as `gp1`.
    #[prost(string, tag = "3")]
    pub kind: ::prost::alloc::string::String,
    /// How its vCPUs are allocated, such as `core`: dedicated and guaranteed.
    #[prost(string, tag = "4")]
    pub cpu_allocation_mode: ::prost::alloc::string::String,
    /// The vCPUs an instance of the type has.
    #[prost(int32, tag = "5")]
    pub vcpu: i32,
    /// The memory an instance of the type has, in MiB.
    #[prost(int32, tag = "6")]
    pub memory_mib: i32,
    /// The most an instance of the type reads and writes across all its
    /// volumes together, in megabits per second; 0 when it isn't limited.
    #[prost(int32, tag = "7")]
    pub storage_bandwidth_mbit: i32,
    /// The rate an instance of the type can burst to above
    /// `storage_bandwidth_mbit`, in megabits per second, for 60 seconds of
    /// traffic at that rate, which staying under the limit refills; 0 when it
    /// can't burst.
    #[prost(int32, tag = "8")]
    pub storage_burst_bandwidth_mbit: i32,
    /// Whether an instance can be launched as, or changed to, the type now. A
    /// type listed but not available is no longer offered; instances already
    /// of the type keep running.
    #[prost(bool, tag = "9")]
    pub available: bool,
}
/// A stable name for the current public image of an operating system
/// release.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ImageFamily {
    /// The family's resource name, `imageFamilies/ubuntu-24-04-minimal`.
    /// Never renamed, and never reused for another release.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The name the console shows.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// What the family's images hold.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Who publishes the release, such as `Canonical`.
    #[prost(string, tag = "4")]
    pub vendor: ::prost::alloc::string::String,
    /// The operating system, such as `ubuntu`.
    #[prost(string, tag = "5")]
    pub os: ::prost::alloc::string::String,
    /// The release, such as `24.04`.
    #[prost(string, tag = "6")]
    pub os_version: ::prost::alloc::string::String,
    /// When the vendor stops supporting the release; empty when no date is
    /// known. Advisory: launches aren't refused after it.
    #[prost(message, optional, tag = "7")]
    pub support_end_time: ::core::option::Option<
        ::origincloud_core::protobuf::Timestamp,
    >,
    /// Whether an instance can be launched from the family now. Instances
    /// launched from a family no longer offered are unaffected.
    #[prost(bool, tag = "8")]
    pub available: bool,
}
/// The request for GetInstanceType.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetInstanceTypeRequest {
    /// The type to return, `instanceTypes/{instance_type}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request for ListInstanceTypes. The catalog is small and bounded by
/// the platform, so it comes in one page.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListInstanceTypesRequest {}
/// The response for ListInstanceTypes.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListInstanceTypesResponse {
    /// Every instance type, by kind, then by size.
    #[prost(message, repeated, tag = "1")]
    pub instance_types: ::prost::alloc::vec::Vec<InstanceType>,
}
/// The request for GetImageFamily.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetImageFamilyRequest {
    /// The family to return, `imageFamilies/{image_family}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request for ListImageFamilies. The catalog is small and bounded by
/// the platform, so it comes in one page.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListImageFamiliesRequest {}
/// The response for ListImageFamilies.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListImageFamiliesResponse {
    /// Every image family, by name.
    #[prost(message, repeated, tag = "1")]
    pub image_families: ::prost::alloc::vec::Vec<ImageFamily>,
}
/// A project's own image, which an instance's boot volume can be created
/// from.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Image {
    /// The image's resource name.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The image's URN, the identifier access policies and the audit log use.
    #[prost(string, tag = "2")]
    pub urn: ::prost::alloc::string::String,
    /// What the image holds, as you describe it.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// The account an instance launched from the image logs in as, unless the
    /// launch names another: a POSIX user name of at most 32 lowercase
    /// letters, digits, underscores and hyphens, starting with a letter or an
    /// underscore, and not `root`. `cloud` when left empty.
    #[prost(string, tag = "4")]
    pub default_user: ::prost::alloc::string::String,
    /// The device name of the disk the image boots from: one of the
    /// `block_devices`' `device`.
    #[prost(string, tag = "5")]
    pub root_device: ::prost::alloc::string::String,
    /// The image's disks, each created for an instance launched from it.
    #[prost(message, repeated, tag = "6")]
    pub block_devices: ::prost::alloc::vec::Vec<ImageBlockDevice>,
    /// The CPU architecture it boots on.
    #[prost(enumeration = "image::Architecture", tag = "7")]
    pub architecture: i32,
    /// Its operating system family.
    #[prost(enumeration = "image::Platform", tag = "8")]
    pub platform: i32,
    /// Where it is in its lifecycle.
    #[prost(enumeration = "image::State", tag = "9")]
    pub state: i32,
    /// The principal that created the image, such as `user:<id>`.
    #[prost(string, tag = "10")]
    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 = "11")]
    pub tags: ::prost::alloc::collections::BTreeMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
/// Nested message and enum types in `Image`.
pub mod image {
    /// The CPU architecture an image boots on.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Architecture {
        /// Not set.
        Unspecified = 0,
        /// 64-bit x86.
        X8664 = 1,
    }
    impl Architecture {
        /// 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 => "ARCHITECTURE_UNSPECIFIED",
                Self::X8664 => "X86_64",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "ARCHITECTURE_UNSPECIFIED" => Some(Self::Unspecified),
                "X86_64" => Some(Self::X8664),
                _ => None,
            }
        }
    }
    /// The operating system family of an image.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Platform {
        /// Not set.
        Unspecified = 0,
        /// Linux or another Unix.
        LinuxUnix = 1,
    }
    impl Platform {
        /// 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 => "PLATFORM_UNSPECIFIED",
                Self::LinuxUnix => "LINUX_UNIX",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "PLATFORM_UNSPECIFIED" => Some(Self::Unspecified),
                "LINUX_UNIX" => Some(Self::LinuxUnix),
                _ => None,
            }
        }
    }
    /// Where the image is in its lifecycle.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        /// Not set.
        Unspecified = 0,
        /// Instances can be launched from it.
        Available = 1,
    }
    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::Available => "AVAILABLE",
            }
        }
        /// 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),
                "AVAILABLE" => Some(Self::Available),
                _ => None,
            }
        }
    }
}
/// A disk of an image.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ImageBlockDevice {
    /// The device name the disk appears under on every instance launched from
    /// the image: `vda` to `vdz` but `vdc`, unique within the image.
    #[prost(string, tag = "1")]
    pub device: ::prost::alloc::string::String,
    /// The disk's size in GiB, at least the snapshot's.
    #[prost(int32, tag = "2")]
    pub size_gib: i32,
    /// The protected snapshot the disk is created from, in the image's
    /// project and zone; an empty disk when left empty.
    #[prost(string, tag = "3")]
    pub source_snapshot: ::prost::alloc::string::String,
}
/// The request for GetImage.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetImageRequest {
    /// The image to return.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request for ListImages.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListImagesRequest {
    /// The zone whose images to list, `projects/{project}/zones/{zone}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The most images to return; the server clamps it, and 0 means its
    /// default.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// A previous response's `next_page_token`, for the page after it.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// The response for ListImages.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListImagesResponse {
    /// The images on this page.
    #[prost(message, repeated, tag = "1")]
    pub images: ::prost::alloc::vec::Vec<Image>,
    /// 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 CreateImage.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateImageRequest {
    /// The zone to create the image in, `projects/{project}/zones/{zone}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The image to create: its description, root device and disks, and
    /// optionally its default user and tags.
    #[prost(message, optional, tag = "2")]
    pub image: ::core::option::Option<Image>,
    /// A UUID; a repeat with the same id returns the first request's image
    /// instead of creating a second one.
    #[prost(string, tag = "3")]
    pub request_id: ::prost::alloc::string::String,
}
/// The request for UpdateImage.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateImageRequest {
    /// The image, by its name, with the fields to change.
    #[prost(message, optional, tag = "1")]
    pub image: ::core::option::Option<Image>,
    /// The fields to change: `description`, `tags`, or both. `*` is both.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::origincloud_core::protobuf::FieldMask>,
}
/// The request for DeleteImage.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteImageRequest {
    /// The image to delete.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// A virtual machine in one zone.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Instance {
    /// The instance's resource name.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The instance's URN, the identifier access policies and the audit log
    /// use.
    #[prost(string, tag = "2")]
    pub urn: ::prost::alloc::string::String,
    /// The instance type, `instanceTypes/{instance_type}`, such as
    /// `instanceTypes/gp1.core.2`: one whose `available` is true. Changing it
    /// needs the instance `instance::State::Stopped`.
    #[prost(string, tag = "3")]
    pub instance_type: ::prost::alloc::string::String,
    /// The image the boot volume is created from, in the instance's zone: one
    /// of the project's own, `projects/{project}/zones/{zone}/images/{image}`,
    /// or a public one, `zones/{zone}/images/{image}`. Set exactly one of
    /// `image` and `image_family`; launched from a family, this is the public
    /// image the family resolved to.
    #[prost(string, tag = "4")]
    pub image: ::prost::alloc::string::String,
    /// The image family to launch the current public image of,
    /// `imageFamilies/{image_family}`. Set exactly one of `image` and
    /// `image_family`. Empty when the instance was launched from an image.
    #[prost(string, tag = "5")]
    pub image_family: ::prost::alloc::string::String,
    /// The key pair whose public key is installed for `login_user`, in the
    /// instance's project.
    #[prost(string, tag = "6")]
    pub key_pair: ::prost::alloc::string::String,
    /// The account to log in as: a user created at first boot that holds the
    /// key pair. A POSIX user name of at most 32 lowercase letters, digits,
    /// underscores and hyphens, starting with a letter or an underscore, and
    /// not `root`. The image's `default_user` when left empty.
    #[prost(string, tag = "7")]
    pub login_user: ::prost::alloc::string::String,
    /// The boot volume: its size and storage class at launch, and the volume.
    /// The image's size on the default storage class when left out.
    #[prost(message, optional, tag = "8")]
    pub boot_volume: ::core::option::Option<BootVolume>,
    /// The network interfaces, in device order, the boot interface first;
    /// exactly one today. Each is an existing interface in the instance's
    /// project and zone that nothing else holds, created with the network
    /// service: its subnet and security groups are the instance's.
    /// Terminating the instance releases it, and it stays. An instance
    /// launched before interfaces were named at launch shows the interface
    /// created for it, which is deleted with the instance.
    #[prost(string, repeated, tag = "9")]
    pub network_interfaces: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Where the instance is in its lifecycle.
    #[prost(enumeration = "instance::State", tag = "10")]
    pub state: i32,
    /// Why the instance is `instance::State::Failed`, or why a `instance::State::Stopped` instance went down
    /// when the machine it ran on failed; empty otherwise.
    #[prost(string, tag = "11")]
    pub state_reason: ::prost::alloc::string::String,
    /// Whether the platform can currently confirm the instance is working,
    /// which `state` doesn't say: a `instance::State::Running` instance on a machine that
    /// stopped answering is still `instance::State::Running`.
    #[prost(message, optional, tag = "12")]
    pub health: ::core::option::Option<InstanceHealth>,
    /// When the instance was launched.
    #[prost(message, optional, tag = "13")]
    pub create_time: ::core::option::Option<::origincloud_core::protobuf::Timestamp>,
    /// The principal that launched the instance, such as `user:<id>` or
    /// `service_account:<id>`.
    #[prost(string, tag = "14")]
    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 = "15")]
    pub tags: ::prost::alloc::collections::BTreeMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Each network interface's private addresses, in the order of
    /// `network_interfaces`; an interface not attached yet has none.
    #[prost(message, repeated, tag = "16")]
    pub interface_addresses: ::prost::alloc::vec::Vec<InterfaceAddresses>,
    /// The service account the instance runs as,
    /// `organizations/{organization}/serviceAccounts/{service_account}`: a
    /// `WORKLOAD` service account of the instance's organization that isn't
    /// deleted. Launching with one needs `iam.service_account.act_as` on the
    /// organization as well. Empty for an instance that runs as none.
    #[prost(string, tag = "17")]
    pub service_account: ::prost::alloc::string::String,
}
/// Nested message and enum types in `Instance`.
pub mod instance {
    /// Where the instance is in its lifecycle.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        /// Not set.
        Unspecified = 0,
        /// Its boot volume and network interface are being created; it starts
        /// on its own once they are ready.
        Initializing = 1,
        /// Being placed on a machine and booted.
        Pending = 2,
        /// Running.
        Running = 3,
        /// Shutting down, to `instance::State::Stopped`.
        Stopping = 4,
        /// Stopped: it holds its volumes and addresses, and no compute capacity
        /// is charged.
        Stopped = 5,
        /// Being terminated.
        ShuttingDown = 6,
        /// Terminated. Readable by name for a day.
        Terminated = 7,
        /// A start, a stop or the launch failed; `state_reason` says why. Start
        /// it again, or delete it.
        Failed = 8,
    }
    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::Initializing => "INITIALIZING",
                Self::Pending => "PENDING",
                Self::Running => "RUNNING",
                Self::Stopping => "STOPPING",
                Self::Stopped => "STOPPED",
                Self::ShuttingDown => "SHUTTING_DOWN",
                Self::Terminated => "TERMINATED",
                Self::Failed => "FAILED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATE_UNSPECIFIED" => Some(Self::Unspecified),
                "INITIALIZING" => Some(Self::Initializing),
                "PENDING" => Some(Self::Pending),
                "RUNNING" => Some(Self::Running),
                "STOPPING" => Some(Self::Stopping),
                "STOPPED" => Some(Self::Stopped),
                "SHUTTING_DOWN" => Some(Self::ShuttingDown),
                "TERMINATED" => Some(Self::Terminated),
                "FAILED" => Some(Self::Failed),
                _ => None,
            }
        }
    }
}
/// An instance's boot volume.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct BootVolume {
    /// The size in GiB the volume was created with, at least the image's
    /// size; the image's size when left at 0. Grow the volume itself to
    /// resize it; this keeps the size at launch.
    #[prost(int32, tag = "1")]
    pub size_gib: i32,
    /// The storage class, `storageClasses/{storage_class}` of the persistent
    /// volume service; the default class when left empty.
    #[prost(string, tag = "2")]
    pub storage_class: ::prost::alloc::string::String,
    /// The volume, in the instance's project and zone.
    #[prost(string, tag = "3")]
    pub volume: ::prost::alloc::string::String,
}
/// The private addresses of one of an instance's network interfaces.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct InterfaceAddresses {
    /// The network interface.
    #[prost(string, tag = "1")]
    pub network_interface: ::prost::alloc::string::String,
    /// Its private IPv4 address.
    #[prost(string, tag = "2")]
    pub ipv4_address: ::prost::alloc::string::String,
    /// Its IPv6 address.
    #[prost(string, tag = "3")]
    pub ipv6_address: ::prost::alloc::string::String,
}
/// An instance's health: each check, and their summary.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InstanceHealth {
    /// The summary of `checks`, for a listing that shows one value per
    /// instance. Only the checks say whether a problem is the platform's or
    /// the instance's own.
    #[prost(enumeration = "instance_health::Availability", tag = "1")]
    pub availability: i32,
    /// Every check, always all of them: one with nothing to report is
    /// `instance_health::Availability::NotApplicable` or `health_check::Outcome::InsufficientData`, never left out.
    #[prost(message, repeated, tag = "2")]
    pub checks: ::prost::alloc::vec::Vec<HealthCheck>,
}
/// Nested message and enum types in `InstanceHealth`.
pub mod instance_health {
    /// The summary of the checks.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Availability {
        /// Not set.
        Unspecified = 0,
        /// Every check that applies passed.
        Available = 1,
        /// A check failed.
        Impaired = 2,
        /// A check that applies has no recent observation.
        Unknown = 3,
        /// No check applies, as for a stopped instance.
        NotApplicable = 4,
    }
    impl Availability {
        /// 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 => "AVAILABILITY_UNSPECIFIED",
                Self::Available => "AVAILABLE",
                Self::Impaired => "IMPAIRED",
                Self::Unknown => "UNKNOWN",
                Self::NotApplicable => "NOT_APPLICABLE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "AVAILABILITY_UNSPECIFIED" => Some(Self::Unspecified),
                "AVAILABLE" => Some(Self::Available),
                "IMPAIRED" => Some(Self::Impaired),
                "UNKNOWN" => Some(Self::Unknown),
                "NOT_APPLICABLE" => Some(Self::NotApplicable),
                _ => None,
            }
        }
    }
}
/// One health check of an instance.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct HealthCheck {
    /// What the check observes.
    #[prost(enumeration = "health_check::Kind", tag = "1")]
    pub kind: i32,
    /// Whose the subject is, derived from `kind`.
    #[prost(enumeration = "health_check::Category", tag = "2")]
    pub category: i32,
    /// Its outcome.
    #[prost(enumeration = "health_check::Outcome", tag = "3")]
    pub outcome: i32,
    /// When the check came to `outcome`; empty while nothing has observed it.
    #[prost(message, optional, tag = "4")]
    pub change_time: ::core::option::Option<::origincloud_core::protobuf::Timestamp>,
}
/// Nested message and enum types in `HealthCheck`.
pub mod health_check {
    /// What a check observes.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Kind {
        /// Not set.
        Unspecified = 0,
        /// The machine the instance runs on answers.
        HostReachable = 1,
        /// The machine reports the virtual machine in the state it should be in.
        DomainState = 2,
        /// The instance answers on its network interface.
        NetworkReachable = 3,
        /// The agent in the guest answers.
        GuestAgent = 4,
        /// The virtual machine exists on its machine.
        GuestPresent = 5,
    }
    impl Kind {
        /// 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 => "KIND_UNSPECIFIED",
                Self::HostReachable => "HOST_REACHABLE",
                Self::DomainState => "DOMAIN_STATE",
                Self::NetworkReachable => "NETWORK_REACHABLE",
                Self::GuestAgent => "GUEST_AGENT",
                Self::GuestPresent => "GUEST_PRESENT",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "KIND_UNSPECIFIED" => Some(Self::Unspecified),
                "HOST_REACHABLE" => Some(Self::HostReachable),
                "DOMAIN_STATE" => Some(Self::DomainState),
                "NETWORK_REACHABLE" => Some(Self::NetworkReachable),
                "GUEST_AGENT" => Some(Self::GuestAgent),
                "GUEST_PRESENT" => Some(Self::GuestPresent),
                _ => None,
            }
        }
    }
    /// Whose a check's subject is.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Category {
        /// Not set.
        Unspecified = 0,
        /// The platform underneath the instance.
        System = 1,
        /// The instance's own operating system and network configuration.
        Instance = 2,
    }
    impl Category {
        /// 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 => "CATEGORY_UNSPECIFIED",
                Self::System => "SYSTEM",
                Self::Instance => "INSTANCE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "CATEGORY_UNSPECIFIED" => Some(Self::Unspecified),
                "SYSTEM" => Some(Self::System),
                "INSTANCE" => Some(Self::Instance),
                _ => None,
            }
        }
    }
    /// A check's outcome.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Outcome {
        /// Not set.
        Unspecified = 0,
        /// Passed.
        Ok = 1,
        /// Failed.
        Impaired = 2,
        /// No recent observation.
        InsufficientData = 3,
        /// The check doesn't apply now.
        NotApplicable = 4,
    }
    impl Outcome {
        /// 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 => "OUTCOME_UNSPECIFIED",
                Self::Ok => "OK",
                Self::Impaired => "IMPAIRED",
                Self::InsufficientData => "INSUFFICIENT_DATA",
                Self::NotApplicable => "NOT_APPLICABLE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "OUTCOME_UNSPECIFIED" => Some(Self::Unspecified),
                "OK" => Some(Self::Ok),
                "IMPAIRED" => Some(Self::Impaired),
                "INSUFFICIENT_DATA" => Some(Self::InsufficientData),
                "NOT_APPLICABLE" => Some(Self::NotApplicable),
                _ => None,
            }
        }
    }
}
/// The request for GetInstance.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetInstanceRequest {
    /// The instance to return.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request for ListInstances.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListInstancesRequest {
    /// The zone whose instances to list, `projects/{project}/zones/{zone}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The most instances to return; the server clamps it, and 0 means its
    /// default.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// A previous response's `next_page_token`, for the page after it.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// The response for ListInstances.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListInstancesResponse {
    /// The instances on this page.
    #[prost(message, repeated, tag = "1")]
    pub instances: ::prost::alloc::vec::Vec<Instance>,
    /// 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 CreateInstance.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateInstanceRequest {
    /// The zone to launch the instance in, `projects/{project}/zones/{zone}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The instance to launch: its type, its image or image family, its key
    /// pair and its network interface, and optionally its login user, boot
    /// volume and tags.
    #[prost(message, optional, tag = "2")]
    pub instance: ::core::option::Option<Instance>,
    /// A UUID; a repeat with the same id returns the first request's
    /// operation instead of launching a second instance.
    #[prost(string, tag = "3")]
    pub request_id: ::prost::alloc::string::String,
}
/// The request for UpdateInstance.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateInstanceRequest {
    /// The instance, by its name, with the fields to change.
    #[prost(message, optional, tag = "1")]
    pub instance: ::core::option::Option<Instance>,
    /// The fields to change: `instance_type`, `tags`, or both. `*` is both.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::origincloud_core::protobuf::FieldMask>,
    /// A UUID; a repeat with the same id returns the first request's
    /// operation instead of changing the instance again.
    #[prost(string, tag = "3")]
    pub request_id: ::prost::alloc::string::String,
}
/// The request for DeleteInstance.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteInstanceRequest {
    /// The instance to terminate.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// A UUID; a repeat with the same id returns the first request's
    /// operation.
    #[prost(string, tag = "2")]
    pub request_id: ::prost::alloc::string::String,
}
/// The request for StartInstance.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct StartInstanceRequest {
    /// The instance to start.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// A UUID; a repeat with the same id returns the first request's
    /// operation.
    #[prost(string, tag = "2")]
    pub request_id: ::prost::alloc::string::String,
}
/// The request for StopInstance.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct StopInstanceRequest {
    /// The instance to stop.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// A UUID; a repeat with the same id returns the first request's
    /// operation.
    #[prost(string, tag = "2")]
    pub request_id: ::prost::alloc::string::String,
}
/// An SSH public key, and on creation the private key generated for it.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct KeyPair {
    /// The key pair's resource name.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The key pair's URN, the identifier access policies and the audit log
    /// use.
    #[prost(string, tag = "2")]
    pub urn: ::prost::alloc::string::String,
    /// The OpenSSH public key line, such as `ssh-ed25519 AAAA... comment`.
    /// Left empty, the platform generates the key pair.
    #[prost(string, tag = "3")]
    pub public_key: ::prost::alloc::string::String,
    /// The generated private key in OpenSSH format, in the response that
    /// generated it and never again: the platform keeps only the public key.
    /// Empty in every other response.
    #[prost(string, tag = "4")]
    pub private_key: ::prost::alloc::string::String,
    /// The principal that created the key pair, such as `user:<id>` or
    /// `service_account:<id>`.
    #[prost(string, tag = "5")]
    pub creator: ::prost::alloc::string::String,
    /// Labels of your own, at most 50. The `origin:name` tag is the name the
    /// console shows, and the comment of a generated key.
    #[prost(btree_map = "string, string", tag = "6")]
    pub tags: ::prost::alloc::collections::BTreeMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
/// The request for GetKeyPair.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetKeyPairRequest {
    /// The key pair to return.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request for ListKeyPairs.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListKeyPairsRequest {
    /// The project whose key pairs to list, `projects/{project}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The most key pairs to return; the server clamps it, and 0 means its
    /// default.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// A previous response's `next_page_token`, for the page after it.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// The response for ListKeyPairs.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListKeyPairsResponse {
    /// The key pairs on this page.
    #[prost(message, repeated, tag = "1")]
    pub key_pairs: ::prost::alloc::vec::Vec<KeyPair>,
    /// 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 CreateKeyPair.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateKeyPairRequest {
    /// The project to create the key pair in, `projects/{project}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The key pair to create: the public key to import, or none to generate
    /// one, and optionally its tags.
    #[prost(message, optional, tag = "2")]
    pub key_pair: ::core::option::Option<KeyPair>,
    /// A UUID; a repeat with the same id creates no second key pair. A repeat
    /// importing a key returns the first request's key pair; a repeat
    /// generating one is refused with `CONFLICT`, as the private key went to
    /// the first request only, and the error's `ErrorInfo` metadata names the
    /// key pair under `keyPair`.
    #[prost(string, tag = "3")]
    pub request_id: ::prost::alloc::string::String,
}
/// The request for UpdateKeyPair.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateKeyPairRequest {
    /// The key pair, by its name, with the tags to set.
    #[prost(message, optional, tag = "1")]
    pub key_pair: ::core::option::Option<KeyPair>,
    /// The fields to change: `tags`, the only field that changes. `*` is the
    /// same.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::origincloud_core::protobuf::FieldMask>,
}
/// The request for DeleteKeyPair.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteKeyPairRequest {
    /// The key pair to delete.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// One of the platform's images, in one zone.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PublicImage {
    /// The image's resource name, `zones/{zone}/images/{image}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The image's URN, the identifier access policies and the audit log use.
    #[prost(string, tag = "2")]
    pub urn: ::prost::alloc::string::String,
    /// What the image holds.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// The account an instance launched from the image logs in as, unless the
    /// launch names another.
    #[prost(string, tag = "4")]
    pub default_user: ::prost::alloc::string::String,
    /// The device name of the disk the image boots from.
    #[prost(string, tag = "5")]
    pub root_device: ::prost::alloc::string::String,
    /// The image's disks, each created for an instance launched from it.
    #[prost(message, repeated, tag = "6")]
    pub block_devices: ::prost::alloc::vec::Vec<PublicImageBlockDevice>,
    /// The CPU architecture it boots on.
    #[prost(enumeration = "image::Architecture", tag = "7")]
    pub architecture: i32,
    /// Its operating system family.
    #[prost(enumeration = "image::Platform", tag = "8")]
    pub platform: i32,
    /// Where it is in its lifecycle.
    #[prost(enumeration = "image::State", tag = "9")]
    pub state: i32,
    /// The family the image belongs to, `imageFamilies/{image_family}`; empty
    /// for an image of none.
    #[prost(string, tag = "10")]
    pub image_family: ::prost::alloc::string::String,
    /// Whether `image_family` launches this image now.
    #[prost(bool, tag = "11")]
    pub family_current: bool,
}
/// A disk of a public image.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PublicImageBlockDevice {
    /// The device name the disk appears under on every instance launched from
    /// the image.
    #[prost(string, tag = "1")]
    pub device: ::prost::alloc::string::String,
    /// The disk's size in GiB.
    #[prost(int32, tag = "2")]
    pub size_gib: i32,
}
/// The request for GetPublicImage.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetPublicImageRequest {
    /// The image to return, `zones/{zone}/images/{image}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request for ListPublicImages.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListPublicImagesRequest {
    /// The zone whose public images to list, `zones/{zone}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The most images to return; the server clamps it, and 0 means its
    /// default.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// A previous response's `next_page_token`, for the page after it.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// The response for ListPublicImages.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListPublicImagesResponse {
    /// The images on this page.
    #[prost(message, repeated, tag = "1")]
    pub public_images: ::prost::alloc::vec::Vec<PublicImage>,
    /// The token for the next page; empty on the last one.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// A volume an instance holds.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct VolumeAttachment {
    /// The attachment's resource name.
    #[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 volume, in the instance's project and zone.
    #[prost(string, tag = "3")]
    pub volume: ::prost::alloc::string::String,
    /// The device name the guest sees the volume under, `vda` to `vdz`. The
    /// first free one when left empty.
    #[prost(string, tag = "4")]
    pub device: ::prost::alloc::string::String,
    /// Whether this is the instance's boot volume, which was attached at
    /// launch and can't be detached.
    #[prost(bool, tag = "5")]
    pub boot: bool,
    /// Where the attachment is.
    #[prost(enumeration = "volume_attachment::State", tag = "6")]
    pub state: i32,
}
/// Nested message and enum types in `VolumeAttachment`.
pub mod volume_attachment {
    /// Where the attachment is.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        /// Not set.
        Unspecified = 0,
        /// The volume is being created or claimed for the instance.
        Creating = 1,
        /// Being added to the running guest.
        Attaching = 2,
        /// Attached.
        Attached = 3,
        /// Being removed from the running guest.
        Detaching = 4,
        /// Being released, as the instance is terminated.
        Releasing = 5,
        /// The platform stopped trying to release the volume, which may still
        /// be held.
        ReleaseAbandoned = 6,
        /// The volume couldn't be attached, and was released.
        Failed = 7,
    }
    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::Creating => "CREATING",
                Self::Attaching => "ATTACHING",
                Self::Attached => "ATTACHED",
                Self::Detaching => "DETACHING",
                Self::Releasing => "RELEASING",
                Self::ReleaseAbandoned => "RELEASE_ABANDONED",
                Self::Failed => "FAILED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATE_UNSPECIFIED" => Some(Self::Unspecified),
                "CREATING" => Some(Self::Creating),
                "ATTACHING" => Some(Self::Attaching),
                "ATTACHED" => Some(Self::Attached),
                "DETACHING" => Some(Self::Detaching),
                "RELEASING" => Some(Self::Releasing),
                "RELEASE_ABANDONED" => Some(Self::ReleaseAbandoned),
                "FAILED" => Some(Self::Failed),
                _ => None,
            }
        }
    }
}
/// The request for GetVolumeAttachment.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetVolumeAttachmentRequest {
    /// The attachment to return.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request for ListVolumeAttachments.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListVolumeAttachmentsRequest {
    /// The instance whose attachments to list,
    /// `projects/{project}/zones/{zone}/instances/{instance}`, or `-` for the
    /// instance to list every instance's in the zone.
    #[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 of this volume; every volume's when left empty.
    #[prost(string, tag = "4")]
    pub volume: ::prost::alloc::string::String,
}
/// The response for ListVolumeAttachments.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListVolumeAttachmentsResponse {
    /// The attachments on this page.
    #[prost(message, repeated, tag = "1")]
    pub volume_attachments: ::prost::alloc::vec::Vec<VolumeAttachment>,
    /// 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 CreateVolumeAttachment.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreateVolumeAttachmentRequest {
    /// The instance to attach the volume to,
    /// `projects/{project}/zones/{zone}/instances/{instance}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The attachment to create: its volume, and optionally its device name.
    #[prost(message, optional, tag = "2")]
    pub volume_attachment: ::core::option::Option<VolumeAttachment>,
    /// A UUID; a repeat with the same id returns the first request's
    /// operation instead of attaching again.
    #[prost(string, tag = "3")]
    pub request_id: ::prost::alloc::string::String,
}
/// The request for DeleteVolumeAttachment.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteVolumeAttachmentRequest {
    /// The attachment to delete, detaching its volume.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// A UUID; a repeat with the same id returns the first request's
    /// operation.
    #[prost(string, tag = "2")]
    pub request_id: ::prost::alloc::string::String,
}
impl serde::Serialize for BootVolume {
    #[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.size_gib != 0 {
            len += 1;
        }
        if !self.storage_class.is_empty() {
            len += 1;
        }
        if !self.volume.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.compute.v1beta1.BootVolume", len)?;
        if self.size_gib != 0 {
            struct_ser.serialize_field("sizeGib", &self.size_gib)?;
        }
        if !self.storage_class.is_empty() {
            struct_ser.serialize_field("storageClass", &self.storage_class)?;
        }
        if !self.volume.is_empty() {
            struct_ser.serialize_field("volume", &self.volume)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for BootVolume {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "size_gib",
            "sizeGib",
            "storage_class",
            "storageClass",
            "volume",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            SizeGib,
            StorageClass,
            Volume,
            __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 {
                            "sizeGib" | "size_gib" => Ok(GeneratedField::SizeGib),
                            "storageClass" | "storage_class" => {
                                Ok(GeneratedField::StorageClass)
                            }
                            "volume" => Ok(GeneratedField::Volume),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = BootVolume;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.compute.v1beta1.BootVolume")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<BootVolume, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut size_gib__ = None;
                let mut storage_class__ = None;
                let mut volume__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::SizeGib => {
                            if size_gib__.is_some() {
                                return Err(serde::de::Error::duplicate_field("sizeGib"));
                            }
                            size_gib__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::StorageClass => {
                            if storage_class__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("storageClass"),
                                );
                            }
                            storage_class__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Volume => {
                            if volume__.is_some() {
                                return Err(serde::de::Error::duplicate_field("volume"));
                            }
                            volume__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(BootVolume {
                    size_gib: size_gib__.unwrap_or_default(),
                    storage_class: storage_class__.unwrap_or_default(),
                    volume: volume__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.BootVolume",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for CreateImageRequest {
    #[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.image.is_some() {
            len += 1;
        }
        if !self.request_id.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.compute.v1beta1.CreateImageRequest", len)?;
        if !self.parent.is_empty() {
            struct_ser.serialize_field("parent", &self.parent)?;
        }
        if let Some(v) = self.image.as_ref() {
            struct_ser.serialize_field("image", v)?;
        }
        if !self.request_id.is_empty() {
            struct_ser.serialize_field("requestId", &self.request_id)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for CreateImageRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["parent", "image", "request_id", "requestId"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Parent,
            Image,
            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),
                            "image" => Ok(GeneratedField::Image),
                            "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 = CreateImageRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.compute.v1beta1.CreateImageRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<CreateImageRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut parent__ = None;
                let mut image__ = 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::Image => {
                            if image__.is_some() {
                                return Err(serde::de::Error::duplicate_field("image"));
                            }
                            image__ = 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(CreateImageRequest {
                    parent: parent__.unwrap_or_default(),
                    image: image__,
                    request_id: request_id__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.CreateImageRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for CreateInstanceRequest {
    #[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.instance.is_some() {
            len += 1;
        }
        if !self.request_id.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.compute.v1beta1.CreateInstanceRequest", len)?;
        if !self.parent.is_empty() {
            struct_ser.serialize_field("parent", &self.parent)?;
        }
        if let Some(v) = self.instance.as_ref() {
            struct_ser.serialize_field("instance", v)?;
        }
        if !self.request_id.is_empty() {
            struct_ser.serialize_field("requestId", &self.request_id)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for CreateInstanceRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["parent", "instance", "request_id", "requestId"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Parent,
            Instance,
            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),
                            "instance" => Ok(GeneratedField::Instance),
                            "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 = CreateInstanceRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.compute.v1beta1.CreateInstanceRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<CreateInstanceRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut parent__ = None;
                let mut instance__ = 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::Instance => {
                            if instance__.is_some() {
                                return Err(serde::de::Error::duplicate_field("instance"));
                            }
                            instance__ = 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(CreateInstanceRequest {
                    parent: parent__.unwrap_or_default(),
                    instance: instance__,
                    request_id: request_id__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.CreateInstanceRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for CreateKeyPairRequest {
    #[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.key_pair.is_some() {
            len += 1;
        }
        if !self.request_id.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.compute.v1beta1.CreateKeyPairRequest", len)?;
        if !self.parent.is_empty() {
            struct_ser.serialize_field("parent", &self.parent)?;
        }
        if let Some(v) = self.key_pair.as_ref() {
            struct_ser.serialize_field("keyPair", v)?;
        }
        if !self.request_id.is_empty() {
            struct_ser.serialize_field("requestId", &self.request_id)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for CreateKeyPairRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "parent",
            "key_pair",
            "keyPair",
            "request_id",
            "requestId",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Parent,
            KeyPair,
            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),
                            "keyPair" | "key_pair" => Ok(GeneratedField::KeyPair),
                            "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 = CreateKeyPairRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.compute.v1beta1.CreateKeyPairRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<CreateKeyPairRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut parent__ = None;
                let mut key_pair__ = 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::KeyPair => {
                            if key_pair__.is_some() {
                                return Err(serde::de::Error::duplicate_field("keyPair"));
                            }
                            key_pair__ = 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(CreateKeyPairRequest {
                    parent: parent__.unwrap_or_default(),
                    key_pair: key_pair__,
                    request_id: request_id__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.CreateKeyPairRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for CreateVolumeAttachmentRequest {
    #[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.volume_attachment.is_some() {
            len += 1;
        }
        if !self.request_id.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.compute.v1beta1.CreateVolumeAttachmentRequest",
                len,
            )?;
        if !self.parent.is_empty() {
            struct_ser.serialize_field("parent", &self.parent)?;
        }
        if let Some(v) = self.volume_attachment.as_ref() {
            struct_ser.serialize_field("volumeAttachment", v)?;
        }
        if !self.request_id.is_empty() {
            struct_ser.serialize_field("requestId", &self.request_id)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for CreateVolumeAttachmentRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "parent",
            "volume_attachment",
            "volumeAttachment",
            "request_id",
            "requestId",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Parent,
            VolumeAttachment,
            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),
                            "volumeAttachment" | "volume_attachment" => {
                                Ok(GeneratedField::VolumeAttachment)
                            }
                            "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 = CreateVolumeAttachmentRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.compute.v1beta1.CreateVolumeAttachmentRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<CreateVolumeAttachmentRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut parent__ = None;
                let mut volume_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::VolumeAttachment => {
                            if volume_attachment__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("volumeAttachment"),
                                );
                            }
                            volume_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(CreateVolumeAttachmentRequest {
                    parent: parent__.unwrap_or_default(),
                    volume_attachment: volume_attachment__,
                    request_id: request_id__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.CreateVolumeAttachmentRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for DeleteImageRequest {
    #[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.compute.v1beta1.DeleteImageRequest", len)?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for DeleteImageRequest {
    #[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 = DeleteImageRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.compute.v1beta1.DeleteImageRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<DeleteImageRequest, 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(DeleteImageRequest {
                    name: name__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.DeleteImageRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for DeleteInstanceRequest {
    #[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.compute.v1beta1.DeleteInstanceRequest", 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 DeleteInstanceRequest {
    #[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 = DeleteInstanceRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.compute.v1beta1.DeleteInstanceRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<DeleteInstanceRequest, 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(DeleteInstanceRequest {
                    name: name__.unwrap_or_default(),
                    request_id: request_id__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.DeleteInstanceRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for DeleteKeyPairRequest {
    #[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.compute.v1beta1.DeleteKeyPairRequest", len)?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for DeleteKeyPairRequest {
    #[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 = DeleteKeyPairRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.compute.v1beta1.DeleteKeyPairRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<DeleteKeyPairRequest, 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(DeleteKeyPairRequest {
                    name: name__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.DeleteKeyPairRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for DeleteVolumeAttachmentRequest {
    #[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.compute.v1beta1.DeleteVolumeAttachmentRequest",
                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 DeleteVolumeAttachmentRequest {
    #[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 = DeleteVolumeAttachmentRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.compute.v1beta1.DeleteVolumeAttachmentRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<DeleteVolumeAttachmentRequest, 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(DeleteVolumeAttachmentRequest {
                    name: name__.unwrap_or_default(),
                    request_id: request_id__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.DeleteVolumeAttachmentRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for GetImageFamilyRequest {
    #[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.compute.v1beta1.GetImageFamilyRequest", len)?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for GetImageFamilyRequest {
    #[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 = GetImageFamilyRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.compute.v1beta1.GetImageFamilyRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<GetImageFamilyRequest, 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(GetImageFamilyRequest {
                    name: name__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.GetImageFamilyRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for GetImageRequest {
    #[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.compute.v1beta1.GetImageRequest", len)?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for GetImageRequest {
    #[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 = GetImageRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.compute.v1beta1.GetImageRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<GetImageRequest, 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(GetImageRequest {
                    name: name__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.GetImageRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for GetInstanceRequest {
    #[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.compute.v1beta1.GetInstanceRequest", len)?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for GetInstanceRequest {
    #[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 = GetInstanceRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.compute.v1beta1.GetInstanceRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<GetInstanceRequest, 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(GetInstanceRequest {
                    name: name__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.GetInstanceRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for GetInstanceTypeRequest {
    #[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.compute.v1beta1.GetInstanceTypeRequest",
                len,
            )?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for GetInstanceTypeRequest {
    #[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 = GetInstanceTypeRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.compute.v1beta1.GetInstanceTypeRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<GetInstanceTypeRequest, 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(GetInstanceTypeRequest {
                    name: name__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.GetInstanceTypeRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for GetKeyPairRequest {
    #[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.compute.v1beta1.GetKeyPairRequest", len)?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for GetKeyPairRequest {
    #[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 = GetKeyPairRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.compute.v1beta1.GetKeyPairRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<GetKeyPairRequest, 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(GetKeyPairRequest {
                    name: name__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.GetKeyPairRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for GetPublicImageRequest {
    #[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.compute.v1beta1.GetPublicImageRequest", len)?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for GetPublicImageRequest {
    #[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 = GetPublicImageRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.compute.v1beta1.GetPublicImageRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<GetPublicImageRequest, 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(GetPublicImageRequest {
                    name: name__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.GetPublicImageRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for GetVolumeAttachmentRequest {
    #[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.compute.v1beta1.GetVolumeAttachmentRequest",
                len,
            )?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for GetVolumeAttachmentRequest {
    #[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 = GetVolumeAttachmentRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.compute.v1beta1.GetVolumeAttachmentRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<GetVolumeAttachmentRequest, 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(GetVolumeAttachmentRequest {
                    name: name__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.GetVolumeAttachmentRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for HealthCheck {
    #[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.kind != 0 {
            len += 1;
        }
        if self.category != 0 {
            len += 1;
        }
        if self.outcome != 0 {
            len += 1;
        }
        if self.change_time.is_some() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.compute.v1beta1.HealthCheck", len)?;
        if self.kind != 0 {
            let v = health_check::Kind::try_from(self.kind)
                .map_err(|_| serde::ser::Error::custom(
                    format!("Invalid variant {}", self.kind),
                ))?;
            struct_ser.serialize_field("kind", &v)?;
        }
        if self.category != 0 {
            let v = health_check::Category::try_from(self.category)
                .map_err(|_| serde::ser::Error::custom(
                    format!("Invalid variant {}", self.category),
                ))?;
            struct_ser.serialize_field("category", &v)?;
        }
        if self.outcome != 0 {
            let v = health_check::Outcome::try_from(self.outcome)
                .map_err(|_| serde::ser::Error::custom(
                    format!("Invalid variant {}", self.outcome),
                ))?;
            struct_ser.serialize_field("outcome", &v)?;
        }
        if let Some(v) = self.change_time.as_ref() {
            struct_ser.serialize_field("changeTime", v)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for HealthCheck {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "kind",
            "category",
            "outcome",
            "change_time",
            "changeTime",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Kind,
            Category,
            Outcome,
            ChangeTime,
            __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 {
                            "kind" => Ok(GeneratedField::Kind),
                            "category" => Ok(GeneratedField::Category),
                            "outcome" => Ok(GeneratedField::Outcome),
                            "changeTime" | "change_time" => {
                                Ok(GeneratedField::ChangeTime)
                            }
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = HealthCheck;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.compute.v1beta1.HealthCheck")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<HealthCheck, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut kind__ = None;
                let mut category__ = None;
                let mut outcome__ = None;
                let mut change_time__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Kind => {
                            if kind__.is_some() {
                                return Err(serde::de::Error::duplicate_field("kind"));
                            }
                            kind__ = Some(
                                map_.next_value::<health_check::Kind>()? as i32,
                            );
                        }
                        GeneratedField::Category => {
                            if category__.is_some() {
                                return Err(serde::de::Error::duplicate_field("category"));
                            }
                            category__ = Some(
                                map_.next_value::<health_check::Category>()? as i32,
                            );
                        }
                        GeneratedField::Outcome => {
                            if outcome__.is_some() {
                                return Err(serde::de::Error::duplicate_field("outcome"));
                            }
                            outcome__ = Some(
                                map_.next_value::<health_check::Outcome>()? as i32,
                            );
                        }
                        GeneratedField::ChangeTime => {
                            if change_time__.is_some() {
                                return Err(serde::de::Error::duplicate_field("changeTime"));
                            }
                            change_time__ = map_.next_value()?;
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(HealthCheck {
                    kind: kind__.unwrap_or_default(),
                    category: category__.unwrap_or_default(),
                    outcome: outcome__.unwrap_or_default(),
                    change_time: change_time__,
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.HealthCheck",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for health_check::Category {
    #[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 => "CATEGORY_UNSPECIFIED",
            Self::System => "SYSTEM",
            Self::Instance => "INSTANCE",
        };
        serializer.serialize_str(variant)
    }
}
impl<'de> serde::Deserialize<'de> for health_check::Category {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["CATEGORY_UNSPECIFIED", "SYSTEM", "INSTANCE"];
        struct GeneratedVisitor;
        impl serde::de::Visitor<'_> for GeneratedVisitor {
            type Value = health_check::Category;
            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(health_check::Category::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(health_check::Category::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 {
                    "CATEGORY_UNSPECIFIED" => Ok(health_check::Category::Unspecified),
                    "SYSTEM" => Ok(health_check::Category::System),
                    "INSTANCE" => Ok(health_check::Category::Instance),
                    _ => Ok(health_check::Category::default()),
                }
            }
        }
        deserializer.deserialize_any(GeneratedVisitor)
    }
}
impl serde::Serialize for health_check::Kind {
    #[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 => "KIND_UNSPECIFIED",
            Self::HostReachable => "HOST_REACHABLE",
            Self::DomainState => "DOMAIN_STATE",
            Self::NetworkReachable => "NETWORK_REACHABLE",
            Self::GuestAgent => "GUEST_AGENT",
            Self::GuestPresent => "GUEST_PRESENT",
        };
        serializer.serialize_str(variant)
    }
}
impl<'de> serde::Deserialize<'de> for health_check::Kind {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "KIND_UNSPECIFIED",
            "HOST_REACHABLE",
            "DOMAIN_STATE",
            "NETWORK_REACHABLE",
            "GUEST_AGENT",
            "GUEST_PRESENT",
        ];
        struct GeneratedVisitor;
        impl serde::de::Visitor<'_> for GeneratedVisitor {
            type Value = health_check::Kind;
            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(health_check::Kind::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(health_check::Kind::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 {
                    "KIND_UNSPECIFIED" => Ok(health_check::Kind::Unspecified),
                    "HOST_REACHABLE" => Ok(health_check::Kind::HostReachable),
                    "DOMAIN_STATE" => Ok(health_check::Kind::DomainState),
                    "NETWORK_REACHABLE" => Ok(health_check::Kind::NetworkReachable),
                    "GUEST_AGENT" => Ok(health_check::Kind::GuestAgent),
                    "GUEST_PRESENT" => Ok(health_check::Kind::GuestPresent),
                    _ => Ok(health_check::Kind::default()),
                }
            }
        }
        deserializer.deserialize_any(GeneratedVisitor)
    }
}
impl serde::Serialize for health_check::Outcome {
    #[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 => "OUTCOME_UNSPECIFIED",
            Self::Ok => "OK",
            Self::Impaired => "IMPAIRED",
            Self::InsufficientData => "INSUFFICIENT_DATA",
            Self::NotApplicable => "NOT_APPLICABLE",
        };
        serializer.serialize_str(variant)
    }
}
impl<'de> serde::Deserialize<'de> for health_check::Outcome {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "OUTCOME_UNSPECIFIED",
            "OK",
            "IMPAIRED",
            "INSUFFICIENT_DATA",
            "NOT_APPLICABLE",
        ];
        struct GeneratedVisitor;
        impl serde::de::Visitor<'_> for GeneratedVisitor {
            type Value = health_check::Outcome;
            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(health_check::Outcome::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(health_check::Outcome::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 {
                    "OUTCOME_UNSPECIFIED" => Ok(health_check::Outcome::Unspecified),
                    "OK" => Ok(health_check::Outcome::Ok),
                    "IMPAIRED" => Ok(health_check::Outcome::Impaired),
                    "INSUFFICIENT_DATA" => Ok(health_check::Outcome::InsufficientData),
                    "NOT_APPLICABLE" => Ok(health_check::Outcome::NotApplicable),
                    _ => Ok(health_check::Outcome::default()),
                }
            }
        }
        deserializer.deserialize_any(GeneratedVisitor)
    }
}
impl serde::Serialize for Image {
    #[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.description.is_empty() {
            len += 1;
        }
        if !self.default_user.is_empty() {
            len += 1;
        }
        if !self.root_device.is_empty() {
            len += 1;
        }
        if !self.block_devices.is_empty() {
            len += 1;
        }
        if self.architecture != 0 {
            len += 1;
        }
        if self.platform != 0 {
            len += 1;
        }
        if self.state != 0 {
            len += 1;
        }
        if !self.creator.is_empty() {
            len += 1;
        }
        if !self.tags.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.compute.v1beta1.Image", 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.description.is_empty() {
            struct_ser.serialize_field("description", &self.description)?;
        }
        if !self.default_user.is_empty() {
            struct_ser.serialize_field("defaultUser", &self.default_user)?;
        }
        if !self.root_device.is_empty() {
            struct_ser.serialize_field("rootDevice", &self.root_device)?;
        }
        if !self.block_devices.is_empty() {
            struct_ser.serialize_field("blockDevices", &self.block_devices)?;
        }
        if self.architecture != 0 {
            let v = image::Architecture::try_from(self.architecture)
                .map_err(|_| serde::ser::Error::custom(
                    format!("Invalid variant {}", self.architecture),
                ))?;
            struct_ser.serialize_field("architecture", &v)?;
        }
        if self.platform != 0 {
            let v = image::Platform::try_from(self.platform)
                .map_err(|_| serde::ser::Error::custom(
                    format!("Invalid variant {}", self.platform),
                ))?;
            struct_ser.serialize_field("platform", &v)?;
        }
        if self.state != 0 {
            let v = image::State::try_from(self.state)
                .map_err(|_| serde::ser::Error::custom(
                    format!("Invalid variant {}", self.state),
                ))?;
            struct_ser.serialize_field("state", &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 Image {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "name",
            "urn",
            "description",
            "default_user",
            "defaultUser",
            "root_device",
            "rootDevice",
            "block_devices",
            "blockDevices",
            "architecture",
            "platform",
            "state",
            "creator",
            "tags",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            Urn,
            Description,
            DefaultUser,
            RootDevice,
            BlockDevices,
            Architecture,
            Platform,
            State,
            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),
                            "description" => Ok(GeneratedField::Description),
                            "defaultUser" | "default_user" => {
                                Ok(GeneratedField::DefaultUser)
                            }
                            "rootDevice" | "root_device" => {
                                Ok(GeneratedField::RootDevice)
                            }
                            "blockDevices" | "block_devices" => {
                                Ok(GeneratedField::BlockDevices)
                            }
                            "architecture" => Ok(GeneratedField::Architecture),
                            "platform" => Ok(GeneratedField::Platform),
                            "state" => Ok(GeneratedField::State),
                            "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 = Image;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.compute.v1beta1.Image")
            }
            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Image, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                let mut urn__ = None;
                let mut description__ = None;
                let mut default_user__ = None;
                let mut root_device__ = None;
                let mut block_devices__ = None;
                let mut architecture__ = None;
                let mut platform__ = None;
                let mut state__ = 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::Description => {
                            if description__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("description"),
                                );
                            }
                            description__ = Some(map_.next_value()?);
                        }
                        GeneratedField::DefaultUser => {
                            if default_user__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("defaultUser"),
                                );
                            }
                            default_user__ = Some(map_.next_value()?);
                        }
                        GeneratedField::RootDevice => {
                            if root_device__.is_some() {
                                return Err(serde::de::Error::duplicate_field("rootDevice"));
                            }
                            root_device__ = Some(map_.next_value()?);
                        }
                        GeneratedField::BlockDevices => {
                            if block_devices__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("blockDevices"),
                                );
                            }
                            block_devices__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Architecture => {
                            if architecture__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("architecture"),
                                );
                            }
                            architecture__ = Some(
                                map_.next_value::<image::Architecture>()? as i32,
                            );
                        }
                        GeneratedField::Platform => {
                            if platform__.is_some() {
                                return Err(serde::de::Error::duplicate_field("platform"));
                            }
                            platform__ = Some(
                                map_.next_value::<image::Platform>()? as i32,
                            );
                        }
                        GeneratedField::State => {
                            if state__.is_some() {
                                return Err(serde::de::Error::duplicate_field("state"));
                            }
                            state__ = Some(map_.next_value::<image::State>()? as i32);
                        }
                        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(Image {
                    name: name__.unwrap_or_default(),
                    urn: urn__.unwrap_or_default(),
                    description: description__.unwrap_or_default(),
                    default_user: default_user__.unwrap_or_default(),
                    root_device: root_device__.unwrap_or_default(),
                    block_devices: block_devices__.unwrap_or_default(),
                    architecture: architecture__.unwrap_or_default(),
                    platform: platform__.unwrap_or_default(),
                    state: state__.unwrap_or_default(),
                    creator: creator__.unwrap_or_default(),
                    tags: tags__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.Image",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for image::Architecture {
    #[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 => "ARCHITECTURE_UNSPECIFIED",
            Self::X8664 => "X86_64",
        };
        serializer.serialize_str(variant)
    }
}
impl<'de> serde::Deserialize<'de> for image::Architecture {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["ARCHITECTURE_UNSPECIFIED", "X86_64"];
        struct GeneratedVisitor;
        impl serde::de::Visitor<'_> for GeneratedVisitor {
            type Value = image::Architecture;
            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(image::Architecture::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(image::Architecture::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 {
                    "ARCHITECTURE_UNSPECIFIED" => Ok(image::Architecture::Unspecified),
                    "X86_64" => Ok(image::Architecture::X8664),
                    _ => Ok(image::Architecture::default()),
                }
            }
        }
        deserializer.deserialize_any(GeneratedVisitor)
    }
}
impl serde::Serialize for image::Platform {
    #[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 => "PLATFORM_UNSPECIFIED",
            Self::LinuxUnix => "LINUX_UNIX",
        };
        serializer.serialize_str(variant)
    }
}
impl<'de> serde::Deserialize<'de> for image::Platform {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["PLATFORM_UNSPECIFIED", "LINUX_UNIX"];
        struct GeneratedVisitor;
        impl serde::de::Visitor<'_> for GeneratedVisitor {
            type Value = image::Platform;
            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(image::Platform::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(image::Platform::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 {
                    "PLATFORM_UNSPECIFIED" => Ok(image::Platform::Unspecified),
                    "LINUX_UNIX" => Ok(image::Platform::LinuxUnix),
                    _ => Ok(image::Platform::default()),
                }
            }
        }
        deserializer.deserialize_any(GeneratedVisitor)
    }
}
impl serde::Serialize for image::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::Available => "AVAILABLE",
        };
        serializer.serialize_str(variant)
    }
}
impl<'de> serde::Deserialize<'de> for image::State {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["STATE_UNSPECIFIED", "AVAILABLE"];
        struct GeneratedVisitor;
        impl serde::de::Visitor<'_> for GeneratedVisitor {
            type Value = image::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(image::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(image::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(image::State::Unspecified),
                    "AVAILABLE" => Ok(image::State::Available),
                    _ => Ok(image::State::default()),
                }
            }
        }
        deserializer.deserialize_any(GeneratedVisitor)
    }
}
impl serde::Serialize for ImageBlockDevice {
    #[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.device.is_empty() {
            len += 1;
        }
        if self.size_gib != 0 {
            len += 1;
        }
        if !self.source_snapshot.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.compute.v1beta1.ImageBlockDevice", len)?;
        if !self.device.is_empty() {
            struct_ser.serialize_field("device", &self.device)?;
        }
        if self.size_gib != 0 {
            struct_ser.serialize_field("sizeGib", &self.size_gib)?;
        }
        if !self.source_snapshot.is_empty() {
            struct_ser.serialize_field("sourceSnapshot", &self.source_snapshot)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ImageBlockDevice {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "device",
            "size_gib",
            "sizeGib",
            "source_snapshot",
            "sourceSnapshot",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Device,
            SizeGib,
            SourceSnapshot,
            __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 {
                            "device" => Ok(GeneratedField::Device),
                            "sizeGib" | "size_gib" => Ok(GeneratedField::SizeGib),
                            "sourceSnapshot" | "source_snapshot" => {
                                Ok(GeneratedField::SourceSnapshot)
                            }
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = ImageBlockDevice;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.compute.v1beta1.ImageBlockDevice")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ImageBlockDevice, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut device__ = None;
                let mut size_gib__ = None;
                let mut source_snapshot__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Device => {
                            if device__.is_some() {
                                return Err(serde::de::Error::duplicate_field("device"));
                            }
                            device__ = Some(map_.next_value()?);
                        }
                        GeneratedField::SizeGib => {
                            if size_gib__.is_some() {
                                return Err(serde::de::Error::duplicate_field("sizeGib"));
                            }
                            size_gib__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::SourceSnapshot => {
                            if source_snapshot__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("sourceSnapshot"),
                                );
                            }
                            source_snapshot__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(ImageBlockDevice {
                    device: device__.unwrap_or_default(),
                    size_gib: size_gib__.unwrap_or_default(),
                    source_snapshot: source_snapshot__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.ImageBlockDevice",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ImageFamily {
    #[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.display_name.is_empty() {
            len += 1;
        }
        if !self.description.is_empty() {
            len += 1;
        }
        if !self.vendor.is_empty() {
            len += 1;
        }
        if !self.os.is_empty() {
            len += 1;
        }
        if !self.os_version.is_empty() {
            len += 1;
        }
        if self.support_end_time.is_some() {
            len += 1;
        }
        if self.available {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.compute.v1beta1.ImageFamily", len)?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        if !self.display_name.is_empty() {
            struct_ser.serialize_field("displayName", &self.display_name)?;
        }
        if !self.description.is_empty() {
            struct_ser.serialize_field("description", &self.description)?;
        }
        if !self.vendor.is_empty() {
            struct_ser.serialize_field("vendor", &self.vendor)?;
        }
        if !self.os.is_empty() {
            struct_ser.serialize_field("os", &self.os)?;
        }
        if !self.os_version.is_empty() {
            struct_ser.serialize_field("osVersion", &self.os_version)?;
        }
        if let Some(v) = self.support_end_time.as_ref() {
            struct_ser.serialize_field("supportEndTime", v)?;
        }
        if self.available {
            struct_ser.serialize_field("available", &self.available)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ImageFamily {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "name",
            "display_name",
            "displayName",
            "description",
            "vendor",
            "os",
            "os_version",
            "osVersion",
            "support_end_time",
            "supportEndTime",
            "available",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            DisplayName,
            Description,
            Vendor,
            Os,
            OsVersion,
            SupportEndTime,
            Available,
            __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),
                            "displayName" | "display_name" => {
                                Ok(GeneratedField::DisplayName)
                            }
                            "description" => Ok(GeneratedField::Description),
                            "vendor" => Ok(GeneratedField::Vendor),
                            "os" => Ok(GeneratedField::Os),
                            "osVersion" | "os_version" => Ok(GeneratedField::OsVersion),
                            "supportEndTime" | "support_end_time" => {
                                Ok(GeneratedField::SupportEndTime)
                            }
                            "available" => Ok(GeneratedField::Available),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = ImageFamily;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.compute.v1beta1.ImageFamily")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ImageFamily, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                let mut display_name__ = None;
                let mut description__ = None;
                let mut vendor__ = None;
                let mut os__ = None;
                let mut os_version__ = None;
                let mut support_end_time__ = None;
                let mut available__ = 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::DisplayName => {
                            if display_name__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("displayName"),
                                );
                            }
                            display_name__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Description => {
                            if description__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("description"),
                                );
                            }
                            description__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Vendor => {
                            if vendor__.is_some() {
                                return Err(serde::de::Error::duplicate_field("vendor"));
                            }
                            vendor__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Os => {
                            if os__.is_some() {
                                return Err(serde::de::Error::duplicate_field("os"));
                            }
                            os__ = Some(map_.next_value()?);
                        }
                        GeneratedField::OsVersion => {
                            if os_version__.is_some() {
                                return Err(serde::de::Error::duplicate_field("osVersion"));
                            }
                            os_version__ = Some(map_.next_value()?);
                        }
                        GeneratedField::SupportEndTime => {
                            if support_end_time__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("supportEndTime"),
                                );
                            }
                            support_end_time__ = map_.next_value()?;
                        }
                        GeneratedField::Available => {
                            if available__.is_some() {
                                return Err(serde::de::Error::duplicate_field("available"));
                            }
                            available__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(ImageFamily {
                    name: name__.unwrap_or_default(),
                    display_name: display_name__.unwrap_or_default(),
                    description: description__.unwrap_or_default(),
                    vendor: vendor__.unwrap_or_default(),
                    os: os__.unwrap_or_default(),
                    os_version: os_version__.unwrap_or_default(),
                    support_end_time: support_end_time__,
                    available: available__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.ImageFamily",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for Instance {
    #[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.instance_type.is_empty() {
            len += 1;
        }
        if !self.image.is_empty() {
            len += 1;
        }
        if !self.image_family.is_empty() {
            len += 1;
        }
        if !self.key_pair.is_empty() {
            len += 1;
        }
        if !self.login_user.is_empty() {
            len += 1;
        }
        if self.boot_volume.is_some() {
            len += 1;
        }
        if !self.network_interfaces.is_empty() {
            len += 1;
        }
        if self.state != 0 {
            len += 1;
        }
        if !self.state_reason.is_empty() {
            len += 1;
        }
        if self.health.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;
        }
        if !self.interface_addresses.is_empty() {
            len += 1;
        }
        if !self.service_account.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.compute.v1beta1.Instance", 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.instance_type.is_empty() {
            struct_ser.serialize_field("instanceType", &self.instance_type)?;
        }
        if !self.image.is_empty() {
            struct_ser.serialize_field("image", &self.image)?;
        }
        if !self.image_family.is_empty() {
            struct_ser.serialize_field("imageFamily", &self.image_family)?;
        }
        if !self.key_pair.is_empty() {
            struct_ser.serialize_field("keyPair", &self.key_pair)?;
        }
        if !self.login_user.is_empty() {
            struct_ser.serialize_field("loginUser", &self.login_user)?;
        }
        if let Some(v) = self.boot_volume.as_ref() {
            struct_ser.serialize_field("bootVolume", v)?;
        }
        if !self.network_interfaces.is_empty() {
            struct_ser.serialize_field("networkInterfaces", &self.network_interfaces)?;
        }
        if self.state != 0 {
            let v = instance::State::try_from(self.state)
                .map_err(|_| serde::ser::Error::custom(
                    format!("Invalid variant {}", self.state),
                ))?;
            struct_ser.serialize_field("state", &v)?;
        }
        if !self.state_reason.is_empty() {
            struct_ser.serialize_field("stateReason", &self.state_reason)?;
        }
        if let Some(v) = self.health.as_ref() {
            struct_ser.serialize_field("health", 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)?;
        }
        if !self.interface_addresses.is_empty() {
            struct_ser.serialize_field("interfaceAddresses", &self.interface_addresses)?;
        }
        if !self.service_account.is_empty() {
            struct_ser.serialize_field("serviceAccount", &self.service_account)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for Instance {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "name",
            "urn",
            "instance_type",
            "instanceType",
            "image",
            "image_family",
            "imageFamily",
            "key_pair",
            "keyPair",
            "login_user",
            "loginUser",
            "boot_volume",
            "bootVolume",
            "network_interfaces",
            "networkInterfaces",
            "state",
            "state_reason",
            "stateReason",
            "health",
            "create_time",
            "createTime",
            "creator",
            "tags",
            "interface_addresses",
            "interfaceAddresses",
            "service_account",
            "serviceAccount",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            Urn,
            InstanceType,
            Image,
            ImageFamily,
            KeyPair,
            LoginUser,
            BootVolume,
            NetworkInterfaces,
            State,
            StateReason,
            Health,
            CreateTime,
            Creator,
            Tags,
            InterfaceAddresses,
            ServiceAccount,
            __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),
                            "instanceType" | "instance_type" => {
                                Ok(GeneratedField::InstanceType)
                            }
                            "image" => Ok(GeneratedField::Image),
                            "imageFamily" | "image_family" => {
                                Ok(GeneratedField::ImageFamily)
                            }
                            "keyPair" | "key_pair" => Ok(GeneratedField::KeyPair),
                            "loginUser" | "login_user" => Ok(GeneratedField::LoginUser),
                            "bootVolume" | "boot_volume" => {
                                Ok(GeneratedField::BootVolume)
                            }
                            "networkInterfaces" | "network_interfaces" => {
                                Ok(GeneratedField::NetworkInterfaces)
                            }
                            "state" => Ok(GeneratedField::State),
                            "stateReason" | "state_reason" => {
                                Ok(GeneratedField::StateReason)
                            }
                            "health" => Ok(GeneratedField::Health),
                            "createTime" | "create_time" => {
                                Ok(GeneratedField::CreateTime)
                            }
                            "creator" => Ok(GeneratedField::Creator),
                            "tags" => Ok(GeneratedField::Tags),
                            "interfaceAddresses" | "interface_addresses" => {
                                Ok(GeneratedField::InterfaceAddresses)
                            }
                            "serviceAccount" | "service_account" => {
                                Ok(GeneratedField::ServiceAccount)
                            }
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = Instance;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.compute.v1beta1.Instance")
            }
            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Instance, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                let mut urn__ = None;
                let mut instance_type__ = None;
                let mut image__ = None;
                let mut image_family__ = None;
                let mut key_pair__ = None;
                let mut login_user__ = None;
                let mut boot_volume__ = None;
                let mut network_interfaces__ = None;
                let mut state__ = None;
                let mut state_reason__ = None;
                let mut health__ = None;
                let mut create_time__ = None;
                let mut creator__ = None;
                let mut tags__ = None;
                let mut interface_addresses__ = None;
                let mut service_account__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Name => {
                            if name__.is_some() {
                                return Err(serde::de::Error::duplicate_field("name"));
                            }
                            name__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Urn => {
                            if urn__.is_some() {
                                return Err(serde::de::Error::duplicate_field("urn"));
                            }
                            urn__ = Some(map_.next_value()?);
                        }
                        GeneratedField::InstanceType => {
                            if instance_type__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("instanceType"),
                                );
                            }
                            instance_type__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Image => {
                            if image__.is_some() {
                                return Err(serde::de::Error::duplicate_field("image"));
                            }
                            image__ = Some(map_.next_value()?);
                        }
                        GeneratedField::ImageFamily => {
                            if image_family__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("imageFamily"),
                                );
                            }
                            image_family__ = Some(map_.next_value()?);
                        }
                        GeneratedField::KeyPair => {
                            if key_pair__.is_some() {
                                return Err(serde::de::Error::duplicate_field("keyPair"));
                            }
                            key_pair__ = Some(map_.next_value()?);
                        }
                        GeneratedField::LoginUser => {
                            if login_user__.is_some() {
                                return Err(serde::de::Error::duplicate_field("loginUser"));
                            }
                            login_user__ = Some(map_.next_value()?);
                        }
                        GeneratedField::BootVolume => {
                            if boot_volume__.is_some() {
                                return Err(serde::de::Error::duplicate_field("bootVolume"));
                            }
                            boot_volume__ = map_.next_value()?;
                        }
                        GeneratedField::NetworkInterfaces => {
                            if network_interfaces__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("networkInterfaces"),
                                );
                            }
                            network_interfaces__ = Some(map_.next_value()?);
                        }
                        GeneratedField::State => {
                            if state__.is_some() {
                                return Err(serde::de::Error::duplicate_field("state"));
                            }
                            state__ = Some(map_.next_value::<instance::State>()? as i32);
                        }
                        GeneratedField::StateReason => {
                            if state_reason__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("stateReason"),
                                );
                            }
                            state_reason__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Health => {
                            if health__.is_some() {
                                return Err(serde::de::Error::duplicate_field("health"));
                            }
                            health__ = 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::InterfaceAddresses => {
                            if interface_addresses__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("interfaceAddresses"),
                                );
                            }
                            interface_addresses__ = Some(map_.next_value()?);
                        }
                        GeneratedField::ServiceAccount => {
                            if service_account__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("serviceAccount"),
                                );
                            }
                            service_account__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(Instance {
                    name: name__.unwrap_or_default(),
                    urn: urn__.unwrap_or_default(),
                    instance_type: instance_type__.unwrap_or_default(),
                    image: image__.unwrap_or_default(),
                    image_family: image_family__.unwrap_or_default(),
                    key_pair: key_pair__.unwrap_or_default(),
                    login_user: login_user__.unwrap_or_default(),
                    boot_volume: boot_volume__,
                    network_interfaces: network_interfaces__.unwrap_or_default(),
                    state: state__.unwrap_or_default(),
                    state_reason: state_reason__.unwrap_or_default(),
                    health: health__,
                    create_time: create_time__,
                    creator: creator__.unwrap_or_default(),
                    tags: tags__.unwrap_or_default(),
                    interface_addresses: interface_addresses__.unwrap_or_default(),
                    service_account: service_account__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.Instance",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for instance::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::Initializing => "INITIALIZING",
            Self::Pending => "PENDING",
            Self::Running => "RUNNING",
            Self::Stopping => "STOPPING",
            Self::Stopped => "STOPPED",
            Self::ShuttingDown => "SHUTTING_DOWN",
            Self::Terminated => "TERMINATED",
            Self::Failed => "FAILED",
        };
        serializer.serialize_str(variant)
    }
}
impl<'de> serde::Deserialize<'de> for instance::State {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "STATE_UNSPECIFIED",
            "INITIALIZING",
            "PENDING",
            "RUNNING",
            "STOPPING",
            "STOPPED",
            "SHUTTING_DOWN",
            "TERMINATED",
            "FAILED",
        ];
        struct GeneratedVisitor;
        impl serde::de::Visitor<'_> for GeneratedVisitor {
            type Value = instance::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(instance::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(instance::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(instance::State::Unspecified),
                    "INITIALIZING" => Ok(instance::State::Initializing),
                    "PENDING" => Ok(instance::State::Pending),
                    "RUNNING" => Ok(instance::State::Running),
                    "STOPPING" => Ok(instance::State::Stopping),
                    "STOPPED" => Ok(instance::State::Stopped),
                    "SHUTTING_DOWN" => Ok(instance::State::ShuttingDown),
                    "TERMINATED" => Ok(instance::State::Terminated),
                    "FAILED" => Ok(instance::State::Failed),
                    _ => Ok(instance::State::default()),
                }
            }
        }
        deserializer.deserialize_any(GeneratedVisitor)
    }
}
impl serde::Serialize for InstanceHealth {
    #[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.availability != 0 {
            len += 1;
        }
        if !self.checks.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.compute.v1beta1.InstanceHealth", len)?;
        if self.availability != 0 {
            let v = instance_health::Availability::try_from(self.availability)
                .map_err(|_| serde::ser::Error::custom(
                    format!("Invalid variant {}", self.availability),
                ))?;
            struct_ser.serialize_field("availability", &v)?;
        }
        if !self.checks.is_empty() {
            struct_ser.serialize_field("checks", &self.checks)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for InstanceHealth {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["availability", "checks"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Availability,
            Checks,
            __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 {
                            "availability" => Ok(GeneratedField::Availability),
                            "checks" => Ok(GeneratedField::Checks),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = InstanceHealth;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.compute.v1beta1.InstanceHealth")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<InstanceHealth, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut availability__ = None;
                let mut checks__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Availability => {
                            if availability__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("availability"),
                                );
                            }
                            availability__ = Some(
                                map_.next_value::<instance_health::Availability>()? as i32,
                            );
                        }
                        GeneratedField::Checks => {
                            if checks__.is_some() {
                                return Err(serde::de::Error::duplicate_field("checks"));
                            }
                            checks__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(InstanceHealth {
                    availability: availability__.unwrap_or_default(),
                    checks: checks__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.InstanceHealth",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for instance_health::Availability {
    #[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 => "AVAILABILITY_UNSPECIFIED",
            Self::Available => "AVAILABLE",
            Self::Impaired => "IMPAIRED",
            Self::Unknown => "UNKNOWN",
            Self::NotApplicable => "NOT_APPLICABLE",
        };
        serializer.serialize_str(variant)
    }
}
impl<'de> serde::Deserialize<'de> for instance_health::Availability {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "AVAILABILITY_UNSPECIFIED",
            "AVAILABLE",
            "IMPAIRED",
            "UNKNOWN",
            "NOT_APPLICABLE",
        ];
        struct GeneratedVisitor;
        impl serde::de::Visitor<'_> for GeneratedVisitor {
            type Value = instance_health::Availability;
            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(instance_health::Availability::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(instance_health::Availability::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 {
                    "AVAILABILITY_UNSPECIFIED" => {
                        Ok(instance_health::Availability::Unspecified)
                    }
                    "AVAILABLE" => Ok(instance_health::Availability::Available),
                    "IMPAIRED" => Ok(instance_health::Availability::Impaired),
                    "UNKNOWN" => Ok(instance_health::Availability::Unknown),
                    "NOT_APPLICABLE" => Ok(instance_health::Availability::NotApplicable),
                    _ => Ok(instance_health::Availability::default()),
                }
            }
        }
        deserializer.deserialize_any(GeneratedVisitor)
    }
}
impl serde::Serialize for InstanceType {
    #[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.display_name.is_empty() {
            len += 1;
        }
        if !self.kind.is_empty() {
            len += 1;
        }
        if !self.cpu_allocation_mode.is_empty() {
            len += 1;
        }
        if self.vcpu != 0 {
            len += 1;
        }
        if self.memory_mib != 0 {
            len += 1;
        }
        if self.storage_bandwidth_mbit != 0 {
            len += 1;
        }
        if self.storage_burst_bandwidth_mbit != 0 {
            len += 1;
        }
        if self.available {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.compute.v1beta1.InstanceType", len)?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        if !self.display_name.is_empty() {
            struct_ser.serialize_field("displayName", &self.display_name)?;
        }
        if !self.kind.is_empty() {
            struct_ser.serialize_field("kind", &self.kind)?;
        }
        if !self.cpu_allocation_mode.is_empty() {
            struct_ser.serialize_field("cpuAllocationMode", &self.cpu_allocation_mode)?;
        }
        if self.vcpu != 0 {
            struct_ser.serialize_field("vcpu", &self.vcpu)?;
        }
        if self.memory_mib != 0 {
            struct_ser.serialize_field("memoryMib", &self.memory_mib)?;
        }
        if self.storage_bandwidth_mbit != 0 {
            struct_ser
                .serialize_field("storageBandwidthMbit", &self.storage_bandwidth_mbit)?;
        }
        if self.storage_burst_bandwidth_mbit != 0 {
            struct_ser
                .serialize_field(
                    "storageBurstBandwidthMbit",
                    &self.storage_burst_bandwidth_mbit,
                )?;
        }
        if self.available {
            struct_ser.serialize_field("available", &self.available)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for InstanceType {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "name",
            "display_name",
            "displayName",
            "kind",
            "cpu_allocation_mode",
            "cpuAllocationMode",
            "vcpu",
            "memory_mib",
            "memoryMib",
            "storage_bandwidth_mbit",
            "storageBandwidthMbit",
            "storage_burst_bandwidth_mbit",
            "storageBurstBandwidthMbit",
            "available",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            DisplayName,
            Kind,
            CpuAllocationMode,
            Vcpu,
            MemoryMib,
            StorageBandwidthMbit,
            StorageBurstBandwidthMbit,
            Available,
            __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),
                            "displayName" | "display_name" => {
                                Ok(GeneratedField::DisplayName)
                            }
                            "kind" => Ok(GeneratedField::Kind),
                            "cpuAllocationMode" | "cpu_allocation_mode" => {
                                Ok(GeneratedField::CpuAllocationMode)
                            }
                            "vcpu" => Ok(GeneratedField::Vcpu),
                            "memoryMib" | "memory_mib" => Ok(GeneratedField::MemoryMib),
                            "storageBandwidthMbit" | "storage_bandwidth_mbit" => {
                                Ok(GeneratedField::StorageBandwidthMbit)
                            }
                            "storageBurstBandwidthMbit"
                            | "storage_burst_bandwidth_mbit" => {
                                Ok(GeneratedField::StorageBurstBandwidthMbit)
                            }
                            "available" => Ok(GeneratedField::Available),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = InstanceType;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.compute.v1beta1.InstanceType")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<InstanceType, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                let mut display_name__ = None;
                let mut kind__ = None;
                let mut cpu_allocation_mode__ = None;
                let mut vcpu__ = None;
                let mut memory_mib__ = None;
                let mut storage_bandwidth_mbit__ = None;
                let mut storage_burst_bandwidth_mbit__ = None;
                let mut available__ = 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::DisplayName => {
                            if display_name__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("displayName"),
                                );
                            }
                            display_name__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Kind => {
                            if kind__.is_some() {
                                return Err(serde::de::Error::duplicate_field("kind"));
                            }
                            kind__ = Some(map_.next_value()?);
                        }
                        GeneratedField::CpuAllocationMode => {
                            if cpu_allocation_mode__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("cpuAllocationMode"),
                                );
                            }
                            cpu_allocation_mode__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Vcpu => {
                            if vcpu__.is_some() {
                                return Err(serde::de::Error::duplicate_field("vcpu"));
                            }
                            vcpu__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::MemoryMib => {
                            if memory_mib__.is_some() {
                                return Err(serde::de::Error::duplicate_field("memoryMib"));
                            }
                            memory_mib__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::StorageBandwidthMbit => {
                            if storage_bandwidth_mbit__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("storageBandwidthMbit"),
                                );
                            }
                            storage_bandwidth_mbit__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::StorageBurstBandwidthMbit => {
                            if storage_burst_bandwidth_mbit__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field(
                                        "storageBurstBandwidthMbit",
                                    ),
                                );
                            }
                            storage_burst_bandwidth_mbit__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::Available => {
                            if available__.is_some() {
                                return Err(serde::de::Error::duplicate_field("available"));
                            }
                            available__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(InstanceType {
                    name: name__.unwrap_or_default(),
                    display_name: display_name__.unwrap_or_default(),
                    kind: kind__.unwrap_or_default(),
                    cpu_allocation_mode: cpu_allocation_mode__.unwrap_or_default(),
                    vcpu: vcpu__.unwrap_or_default(),
                    memory_mib: memory_mib__.unwrap_or_default(),
                    storage_bandwidth_mbit: storage_bandwidth_mbit__.unwrap_or_default(),
                    storage_burst_bandwidth_mbit: storage_burst_bandwidth_mbit__
                        .unwrap_or_default(),
                    available: available__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.InstanceType",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for InterfaceAddresses {
    #[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.network_interface.is_empty() {
            len += 1;
        }
        if !self.ipv4_address.is_empty() {
            len += 1;
        }
        if !self.ipv6_address.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.compute.v1beta1.InterfaceAddresses", len)?;
        if !self.network_interface.is_empty() {
            struct_ser.serialize_field("networkInterface", &self.network_interface)?;
        }
        if !self.ipv4_address.is_empty() {
            struct_ser.serialize_field("ipv4Address", &self.ipv4_address)?;
        }
        if !self.ipv6_address.is_empty() {
            struct_ser.serialize_field("ipv6Address", &self.ipv6_address)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for InterfaceAddresses {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "network_interface",
            "networkInterface",
            "ipv4_address",
            "ipv4Address",
            "ipv6_address",
            "ipv6Address",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            NetworkInterface,
            Ipv4Address,
            Ipv6Address,
            __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 {
                            "networkInterface" | "network_interface" => {
                                Ok(GeneratedField::NetworkInterface)
                            }
                            "ipv4Address" | "ipv4_address" => {
                                Ok(GeneratedField::Ipv4Address)
                            }
                            "ipv6Address" | "ipv6_address" => {
                                Ok(GeneratedField::Ipv6Address)
                            }
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = InterfaceAddresses;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.compute.v1beta1.InterfaceAddresses")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<InterfaceAddresses, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut network_interface__ = None;
                let mut ipv4_address__ = None;
                let mut ipv6_address__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::NetworkInterface => {
                            if network_interface__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("networkInterface"),
                                );
                            }
                            network_interface__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Ipv4Address => {
                            if ipv4_address__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("ipv4Address"),
                                );
                            }
                            ipv4_address__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Ipv6Address => {
                            if ipv6_address__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("ipv6Address"),
                                );
                            }
                            ipv6_address__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(InterfaceAddresses {
                    network_interface: network_interface__.unwrap_or_default(),
                    ipv4_address: ipv4_address__.unwrap_or_default(),
                    ipv6_address: ipv6_address__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.InterfaceAddresses",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for KeyPair {
    #[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.public_key.is_empty() {
            len += 1;
        }
        if !self.private_key.is_empty() {
            len += 1;
        }
        if !self.creator.is_empty() {
            len += 1;
        }
        if !self.tags.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.compute.v1beta1.KeyPair", 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.public_key.is_empty() {
            struct_ser.serialize_field("publicKey", &self.public_key)?;
        }
        if !self.private_key.is_empty() {
            struct_ser.serialize_field("privateKey", &self.private_key)?;
        }
        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 KeyPair {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "name",
            "urn",
            "public_key",
            "publicKey",
            "private_key",
            "privateKey",
            "creator",
            "tags",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            Urn,
            PublicKey,
            PrivateKey,
            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),
                            "publicKey" | "public_key" => Ok(GeneratedField::PublicKey),
                            "privateKey" | "private_key" => {
                                Ok(GeneratedField::PrivateKey)
                            }
                            "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 = KeyPair;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.compute.v1beta1.KeyPair")
            }
            fn visit_map<V>(self, mut map_: V) -> std::result::Result<KeyPair, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                let mut urn__ = None;
                let mut public_key__ = None;
                let mut private_key__ = 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::PublicKey => {
                            if public_key__.is_some() {
                                return Err(serde::de::Error::duplicate_field("publicKey"));
                            }
                            public_key__ = Some(map_.next_value()?);
                        }
                        GeneratedField::PrivateKey => {
                            if private_key__.is_some() {
                                return Err(serde::de::Error::duplicate_field("privateKey"));
                            }
                            private_key__ = Some(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(KeyPair {
                    name: name__.unwrap_or_default(),
                    urn: urn__.unwrap_or_default(),
                    public_key: public_key__.unwrap_or_default(),
                    private_key: private_key__.unwrap_or_default(),
                    creator: creator__.unwrap_or_default(),
                    tags: tags__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.KeyPair",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListImageFamiliesRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let len = 0;
        let struct_ser = serializer
            .serialize_struct(
                "origincloud.compute.v1beta1.ListImageFamiliesRequest",
                len,
            )?;
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ListImageFamiliesRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        Ok(GeneratedField::__SkipField__)
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = ListImageFamiliesRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.compute.v1beta1.ListImageFamiliesRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListImageFamiliesRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                while map_.next_key::<GeneratedField>()?.is_some() {
                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                }
                Ok(ListImageFamiliesRequest {})
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.ListImageFamiliesRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListImageFamiliesResponse {
    #[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.image_families.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.compute.v1beta1.ListImageFamiliesResponse",
                len,
            )?;
        if !self.image_families.is_empty() {
            struct_ser.serialize_field("imageFamilies", &self.image_families)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ListImageFamiliesResponse {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["image_families", "imageFamilies"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            ImageFamilies,
            __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 {
                            "imageFamilies" | "image_families" => {
                                Ok(GeneratedField::ImageFamilies)
                            }
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = ListImageFamiliesResponse;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.compute.v1beta1.ListImageFamiliesResponse",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListImageFamiliesResponse, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut image_families__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::ImageFamilies => {
                            if image_families__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("imageFamilies"),
                                );
                            }
                            image_families__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(ListImageFamiliesResponse {
                    image_families: image_families__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.ListImageFamiliesResponse",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListImagesRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.parent.is_empty() {
            len += 1;
        }
        if self.page_size != 0 {
            len += 1;
        }
        if !self.page_token.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.compute.v1beta1.ListImagesRequest", len)?;
        if !self.parent.is_empty() {
            struct_ser.serialize_field("parent", &self.parent)?;
        }
        if self.page_size != 0 {
            struct_ser.serialize_field("pageSize", &self.page_size)?;
        }
        if !self.page_token.is_empty() {
            struct_ser.serialize_field("pageToken", &self.page_token)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ListImagesRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "parent",
            "page_size",
            "pageSize",
            "page_token",
            "pageToken",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Parent,
            PageSize,
            PageToken,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "parent" => Ok(GeneratedField::Parent),
                            "pageSize" | "page_size" => Ok(GeneratedField::PageSize),
                            "pageToken" | "page_token" => Ok(GeneratedField::PageToken),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = ListImagesRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.compute.v1beta1.ListImagesRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListImagesRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut parent__ = None;
                let mut page_size__ = None;
                let mut page_token__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Parent => {
                            if parent__.is_some() {
                                return Err(serde::de::Error::duplicate_field("parent"));
                            }
                            parent__ = Some(map_.next_value()?);
                        }
                        GeneratedField::PageSize => {
                            if page_size__.is_some() {
                                return Err(serde::de::Error::duplicate_field("pageSize"));
                            }
                            page_size__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::PageToken => {
                            if page_token__.is_some() {
                                return Err(serde::de::Error::duplicate_field("pageToken"));
                            }
                            page_token__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(ListImagesRequest {
                    parent: parent__.unwrap_or_default(),
                    page_size: page_size__.unwrap_or_default(),
                    page_token: page_token__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.ListImagesRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListImagesResponse {
    #[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.images.is_empty() {
            len += 1;
        }
        if !self.next_page_token.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.compute.v1beta1.ListImagesResponse", len)?;
        if !self.images.is_empty() {
            struct_ser.serialize_field("images", &self.images)?;
        }
        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 ListImagesResponse {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["images", "next_page_token", "nextPageToken"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Images,
            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 {
                            "images" => Ok(GeneratedField::Images),
                            "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 = ListImagesResponse;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.compute.v1beta1.ListImagesResponse")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListImagesResponse, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut images__ = None;
                let mut next_page_token__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Images => {
                            if images__.is_some() {
                                return Err(serde::de::Error::duplicate_field("images"));
                            }
                            images__ = 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(ListImagesResponse {
                    images: images__.unwrap_or_default(),
                    next_page_token: next_page_token__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.ListImagesResponse",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListInstanceTypesRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let len = 0;
        let struct_ser = serializer
            .serialize_struct(
                "origincloud.compute.v1beta1.ListInstanceTypesRequest",
                len,
            )?;
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ListInstanceTypesRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        Ok(GeneratedField::__SkipField__)
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = ListInstanceTypesRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.compute.v1beta1.ListInstanceTypesRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListInstanceTypesRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                while map_.next_key::<GeneratedField>()?.is_some() {
                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                }
                Ok(ListInstanceTypesRequest {})
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.ListInstanceTypesRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListInstanceTypesResponse {
    #[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.instance_types.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.compute.v1beta1.ListInstanceTypesResponse",
                len,
            )?;
        if !self.instance_types.is_empty() {
            struct_ser.serialize_field("instanceTypes", &self.instance_types)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ListInstanceTypesResponse {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["instance_types", "instanceTypes"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            InstanceTypes,
            __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 {
                            "instanceTypes" | "instance_types" => {
                                Ok(GeneratedField::InstanceTypes)
                            }
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = ListInstanceTypesResponse;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.compute.v1beta1.ListInstanceTypesResponse",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListInstanceTypesResponse, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut instance_types__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::InstanceTypes => {
                            if instance_types__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("instanceTypes"),
                                );
                            }
                            instance_types__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(ListInstanceTypesResponse {
                    instance_types: instance_types__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.ListInstanceTypesResponse",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListInstancesRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.parent.is_empty() {
            len += 1;
        }
        if self.page_size != 0 {
            len += 1;
        }
        if !self.page_token.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.compute.v1beta1.ListInstancesRequest", len)?;
        if !self.parent.is_empty() {
            struct_ser.serialize_field("parent", &self.parent)?;
        }
        if self.page_size != 0 {
            struct_ser.serialize_field("pageSize", &self.page_size)?;
        }
        if !self.page_token.is_empty() {
            struct_ser.serialize_field("pageToken", &self.page_token)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ListInstancesRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "parent",
            "page_size",
            "pageSize",
            "page_token",
            "pageToken",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Parent,
            PageSize,
            PageToken,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "parent" => Ok(GeneratedField::Parent),
                            "pageSize" | "page_size" => Ok(GeneratedField::PageSize),
                            "pageToken" | "page_token" => Ok(GeneratedField::PageToken),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = ListInstancesRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.compute.v1beta1.ListInstancesRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListInstancesRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut parent__ = None;
                let mut page_size__ = None;
                let mut page_token__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Parent => {
                            if parent__.is_some() {
                                return Err(serde::de::Error::duplicate_field("parent"));
                            }
                            parent__ = Some(map_.next_value()?);
                        }
                        GeneratedField::PageSize => {
                            if page_size__.is_some() {
                                return Err(serde::de::Error::duplicate_field("pageSize"));
                            }
                            page_size__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::PageToken => {
                            if page_token__.is_some() {
                                return Err(serde::de::Error::duplicate_field("pageToken"));
                            }
                            page_token__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(ListInstancesRequest {
                    parent: parent__.unwrap_or_default(),
                    page_size: page_size__.unwrap_or_default(),
                    page_token: page_token__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.ListInstancesRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListInstancesResponse {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.instances.is_empty() {
            len += 1;
        }
        if !self.next_page_token.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.compute.v1beta1.ListInstancesResponse", len)?;
        if !self.instances.is_empty() {
            struct_ser.serialize_field("instances", &self.instances)?;
        }
        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 ListInstancesResponse {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["instances", "next_page_token", "nextPageToken"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Instances,
            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 {
                            "instances" => Ok(GeneratedField::Instances),
                            "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 = ListInstancesResponse;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.compute.v1beta1.ListInstancesResponse",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListInstancesResponse, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut instances__ = None;
                let mut next_page_token__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Instances => {
                            if instances__.is_some() {
                                return Err(serde::de::Error::duplicate_field("instances"));
                            }
                            instances__ = Some(map_.next_value()?);
                        }
                        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(ListInstancesResponse {
                    instances: instances__.unwrap_or_default(),
                    next_page_token: next_page_token__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.ListInstancesResponse",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListKeyPairsRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.parent.is_empty() {
            len += 1;
        }
        if self.page_size != 0 {
            len += 1;
        }
        if !self.page_token.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.compute.v1beta1.ListKeyPairsRequest", len)?;
        if !self.parent.is_empty() {
            struct_ser.serialize_field("parent", &self.parent)?;
        }
        if self.page_size != 0 {
            struct_ser.serialize_field("pageSize", &self.page_size)?;
        }
        if !self.page_token.is_empty() {
            struct_ser.serialize_field("pageToken", &self.page_token)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ListKeyPairsRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "parent",
            "page_size",
            "pageSize",
            "page_token",
            "pageToken",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Parent,
            PageSize,
            PageToken,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "parent" => Ok(GeneratedField::Parent),
                            "pageSize" | "page_size" => Ok(GeneratedField::PageSize),
                            "pageToken" | "page_token" => Ok(GeneratedField::PageToken),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = ListKeyPairsRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.compute.v1beta1.ListKeyPairsRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListKeyPairsRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut parent__ = None;
                let mut page_size__ = None;
                let mut page_token__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Parent => {
                            if parent__.is_some() {
                                return Err(serde::de::Error::duplicate_field("parent"));
                            }
                            parent__ = Some(map_.next_value()?);
                        }
                        GeneratedField::PageSize => {
                            if page_size__.is_some() {
                                return Err(serde::de::Error::duplicate_field("pageSize"));
                            }
                            page_size__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::PageToken => {
                            if page_token__.is_some() {
                                return Err(serde::de::Error::duplicate_field("pageToken"));
                            }
                            page_token__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(ListKeyPairsRequest {
                    parent: parent__.unwrap_or_default(),
                    page_size: page_size__.unwrap_or_default(),
                    page_token: page_token__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.ListKeyPairsRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListKeyPairsResponse {
    #[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.key_pairs.is_empty() {
            len += 1;
        }
        if !self.next_page_token.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.compute.v1beta1.ListKeyPairsResponse", len)?;
        if !self.key_pairs.is_empty() {
            struct_ser.serialize_field("keyPairs", &self.key_pairs)?;
        }
        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 ListKeyPairsResponse {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "key_pairs",
            "keyPairs",
            "next_page_token",
            "nextPageToken",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            KeyPairs,
            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 {
                            "keyPairs" | "key_pairs" => Ok(GeneratedField::KeyPairs),
                            "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 = ListKeyPairsResponse;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.compute.v1beta1.ListKeyPairsResponse")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListKeyPairsResponse, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut key_pairs__ = None;
                let mut next_page_token__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::KeyPairs => {
                            if key_pairs__.is_some() {
                                return Err(serde::de::Error::duplicate_field("keyPairs"));
                            }
                            key_pairs__ = 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(ListKeyPairsResponse {
                    key_pairs: key_pairs__.unwrap_or_default(),
                    next_page_token: next_page_token__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.ListKeyPairsResponse",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListPublicImagesRequest {
    #[allow(deprecated)]
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut len = 0;
        if !self.parent.is_empty() {
            len += 1;
        }
        if self.page_size != 0 {
            len += 1;
        }
        if !self.page_token.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.compute.v1beta1.ListPublicImagesRequest",
                len,
            )?;
        if !self.parent.is_empty() {
            struct_ser.serialize_field("parent", &self.parent)?;
        }
        if self.page_size != 0 {
            struct_ser.serialize_field("pageSize", &self.page_size)?;
        }
        if !self.page_token.is_empty() {
            struct_ser.serialize_field("pageToken", &self.page_token)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ListPublicImagesRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "parent",
            "page_size",
            "pageSize",
            "page_token",
            "pageToken",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Parent,
            PageSize,
            PageToken,
            __SkipField__,
        }
        impl<'de> serde::Deserialize<'de> for GeneratedField {
            fn deserialize<D>(
                deserializer: D,
            ) -> std::result::Result<GeneratedField, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct GeneratedVisitor;
                impl serde::de::Visitor<'_> for GeneratedVisitor {
                    type Value = GeneratedField;
                    fn expecting(
                        &self,
                        formatter: &mut std::fmt::Formatter<'_>,
                    ) -> std::fmt::Result {
                        write!(formatter, "expected one of: {:?}", & FIELDS)
                    }
                    #[allow(unused_variables)]
                    fn visit_str<E>(
                        self,
                        value: &str,
                    ) -> std::result::Result<GeneratedField, E>
                    where
                        E: serde::de::Error,
                    {
                        match value {
                            "parent" => Ok(GeneratedField::Parent),
                            "pageSize" | "page_size" => Ok(GeneratedField::PageSize),
                            "pageToken" | "page_token" => Ok(GeneratedField::PageToken),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = ListPublicImagesRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.compute.v1beta1.ListPublicImagesRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListPublicImagesRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut parent__ = None;
                let mut page_size__ = None;
                let mut page_token__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Parent => {
                            if parent__.is_some() {
                                return Err(serde::de::Error::duplicate_field("parent"));
                            }
                            parent__ = Some(map_.next_value()?);
                        }
                        GeneratedField::PageSize => {
                            if page_size__.is_some() {
                                return Err(serde::de::Error::duplicate_field("pageSize"));
                            }
                            page_size__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::PageToken => {
                            if page_token__.is_some() {
                                return Err(serde::de::Error::duplicate_field("pageToken"));
                            }
                            page_token__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(ListPublicImagesRequest {
                    parent: parent__.unwrap_or_default(),
                    page_size: page_size__.unwrap_or_default(),
                    page_token: page_token__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.ListPublicImagesRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListPublicImagesResponse {
    #[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.public_images.is_empty() {
            len += 1;
        }
        if !self.next_page_token.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.compute.v1beta1.ListPublicImagesResponse",
                len,
            )?;
        if !self.public_images.is_empty() {
            struct_ser.serialize_field("publicImages", &self.public_images)?;
        }
        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 ListPublicImagesResponse {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "public_images",
            "publicImages",
            "next_page_token",
            "nextPageToken",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            PublicImages,
            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 {
                            "publicImages" | "public_images" => {
                                Ok(GeneratedField::PublicImages)
                            }
                            "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 = ListPublicImagesResponse;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.compute.v1beta1.ListPublicImagesResponse",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListPublicImagesResponse, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut public_images__ = None;
                let mut next_page_token__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::PublicImages => {
                            if public_images__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("publicImages"),
                                );
                            }
                            public_images__ = 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(ListPublicImagesResponse {
                    public_images: public_images__.unwrap_or_default(),
                    next_page_token: next_page_token__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.ListPublicImagesResponse",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListVolumeAttachmentsRequest {
    #[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.volume.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.compute.v1beta1.ListVolumeAttachmentsRequest",
                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.volume.is_empty() {
            struct_ser.serialize_field("volume", &self.volume)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ListVolumeAttachmentsRequest {
    #[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",
            "volume",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Parent,
            PageSize,
            PageToken,
            Volume,
            __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),
                            "volume" => Ok(GeneratedField::Volume),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = ListVolumeAttachmentsRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.compute.v1beta1.ListVolumeAttachmentsRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListVolumeAttachmentsRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut parent__ = None;
                let mut page_size__ = None;
                let mut page_token__ = None;
                let mut volume__ = 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::Volume => {
                            if volume__.is_some() {
                                return Err(serde::de::Error::duplicate_field("volume"));
                            }
                            volume__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(ListVolumeAttachmentsRequest {
                    parent: parent__.unwrap_or_default(),
                    page_size: page_size__.unwrap_or_default(),
                    page_token: page_token__.unwrap_or_default(),
                    volume: volume__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.ListVolumeAttachmentsRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListVolumeAttachmentsResponse {
    #[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.volume_attachments.is_empty() {
            len += 1;
        }
        if !self.next_page_token.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.compute.v1beta1.ListVolumeAttachmentsResponse",
                len,
            )?;
        if !self.volume_attachments.is_empty() {
            struct_ser.serialize_field("volumeAttachments", &self.volume_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 ListVolumeAttachmentsResponse {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "volume_attachments",
            "volumeAttachments",
            "next_page_token",
            "nextPageToken",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            VolumeAttachments,
            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 {
                            "volumeAttachments" | "volume_attachments" => {
                                Ok(GeneratedField::VolumeAttachments)
                            }
                            "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 = ListVolumeAttachmentsResponse;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.compute.v1beta1.ListVolumeAttachmentsResponse",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListVolumeAttachmentsResponse, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut volume_attachments__ = None;
                let mut next_page_token__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::VolumeAttachments => {
                            if volume_attachments__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("volumeAttachments"),
                                );
                            }
                            volume_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(ListVolumeAttachmentsResponse {
                    volume_attachments: volume_attachments__.unwrap_or_default(),
                    next_page_token: next_page_token__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.ListVolumeAttachmentsResponse",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for PublicImage {
    #[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.description.is_empty() {
            len += 1;
        }
        if !self.default_user.is_empty() {
            len += 1;
        }
        if !self.root_device.is_empty() {
            len += 1;
        }
        if !self.block_devices.is_empty() {
            len += 1;
        }
        if self.architecture != 0 {
            len += 1;
        }
        if self.platform != 0 {
            len += 1;
        }
        if self.state != 0 {
            len += 1;
        }
        if !self.image_family.is_empty() {
            len += 1;
        }
        if self.family_current {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.compute.v1beta1.PublicImage", 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.description.is_empty() {
            struct_ser.serialize_field("description", &self.description)?;
        }
        if !self.default_user.is_empty() {
            struct_ser.serialize_field("defaultUser", &self.default_user)?;
        }
        if !self.root_device.is_empty() {
            struct_ser.serialize_field("rootDevice", &self.root_device)?;
        }
        if !self.block_devices.is_empty() {
            struct_ser.serialize_field("blockDevices", &self.block_devices)?;
        }
        if self.architecture != 0 {
            let v = image::Architecture::try_from(self.architecture)
                .map_err(|_| serde::ser::Error::custom(
                    format!("Invalid variant {}", self.architecture),
                ))?;
            struct_ser.serialize_field("architecture", &v)?;
        }
        if self.platform != 0 {
            let v = image::Platform::try_from(self.platform)
                .map_err(|_| serde::ser::Error::custom(
                    format!("Invalid variant {}", self.platform),
                ))?;
            struct_ser.serialize_field("platform", &v)?;
        }
        if self.state != 0 {
            let v = image::State::try_from(self.state)
                .map_err(|_| serde::ser::Error::custom(
                    format!("Invalid variant {}", self.state),
                ))?;
            struct_ser.serialize_field("state", &v)?;
        }
        if !self.image_family.is_empty() {
            struct_ser.serialize_field("imageFamily", &self.image_family)?;
        }
        if self.family_current {
            struct_ser.serialize_field("familyCurrent", &self.family_current)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for PublicImage {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "name",
            "urn",
            "description",
            "default_user",
            "defaultUser",
            "root_device",
            "rootDevice",
            "block_devices",
            "blockDevices",
            "architecture",
            "platform",
            "state",
            "image_family",
            "imageFamily",
            "family_current",
            "familyCurrent",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            Urn,
            Description,
            DefaultUser,
            RootDevice,
            BlockDevices,
            Architecture,
            Platform,
            State,
            ImageFamily,
            FamilyCurrent,
            __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),
                            "description" => Ok(GeneratedField::Description),
                            "defaultUser" | "default_user" => {
                                Ok(GeneratedField::DefaultUser)
                            }
                            "rootDevice" | "root_device" => {
                                Ok(GeneratedField::RootDevice)
                            }
                            "blockDevices" | "block_devices" => {
                                Ok(GeneratedField::BlockDevices)
                            }
                            "architecture" => Ok(GeneratedField::Architecture),
                            "platform" => Ok(GeneratedField::Platform),
                            "state" => Ok(GeneratedField::State),
                            "imageFamily" | "image_family" => {
                                Ok(GeneratedField::ImageFamily)
                            }
                            "familyCurrent" | "family_current" => {
                                Ok(GeneratedField::FamilyCurrent)
                            }
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = PublicImage;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.compute.v1beta1.PublicImage")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<PublicImage, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                let mut urn__ = None;
                let mut description__ = None;
                let mut default_user__ = None;
                let mut root_device__ = None;
                let mut block_devices__ = None;
                let mut architecture__ = None;
                let mut platform__ = None;
                let mut state__ = None;
                let mut image_family__ = None;
                let mut family_current__ = 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::Description => {
                            if description__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("description"),
                                );
                            }
                            description__ = Some(map_.next_value()?);
                        }
                        GeneratedField::DefaultUser => {
                            if default_user__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("defaultUser"),
                                );
                            }
                            default_user__ = Some(map_.next_value()?);
                        }
                        GeneratedField::RootDevice => {
                            if root_device__.is_some() {
                                return Err(serde::de::Error::duplicate_field("rootDevice"));
                            }
                            root_device__ = Some(map_.next_value()?);
                        }
                        GeneratedField::BlockDevices => {
                            if block_devices__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("blockDevices"),
                                );
                            }
                            block_devices__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Architecture => {
                            if architecture__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("architecture"),
                                );
                            }
                            architecture__ = Some(
                                map_.next_value::<image::Architecture>()? as i32,
                            );
                        }
                        GeneratedField::Platform => {
                            if platform__.is_some() {
                                return Err(serde::de::Error::duplicate_field("platform"));
                            }
                            platform__ = Some(
                                map_.next_value::<image::Platform>()? as i32,
                            );
                        }
                        GeneratedField::State => {
                            if state__.is_some() {
                                return Err(serde::de::Error::duplicate_field("state"));
                            }
                            state__ = Some(map_.next_value::<image::State>()? as i32);
                        }
                        GeneratedField::ImageFamily => {
                            if image_family__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("imageFamily"),
                                );
                            }
                            image_family__ = Some(map_.next_value()?);
                        }
                        GeneratedField::FamilyCurrent => {
                            if family_current__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("familyCurrent"),
                                );
                            }
                            family_current__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(PublicImage {
                    name: name__.unwrap_or_default(),
                    urn: urn__.unwrap_or_default(),
                    description: description__.unwrap_or_default(),
                    default_user: default_user__.unwrap_or_default(),
                    root_device: root_device__.unwrap_or_default(),
                    block_devices: block_devices__.unwrap_or_default(),
                    architecture: architecture__.unwrap_or_default(),
                    platform: platform__.unwrap_or_default(),
                    state: state__.unwrap_or_default(),
                    image_family: image_family__.unwrap_or_default(),
                    family_current: family_current__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.PublicImage",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for PublicImageBlockDevice {
    #[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.device.is_empty() {
            len += 1;
        }
        if self.size_gib != 0 {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.compute.v1beta1.PublicImageBlockDevice",
                len,
            )?;
        if !self.device.is_empty() {
            struct_ser.serialize_field("device", &self.device)?;
        }
        if self.size_gib != 0 {
            struct_ser.serialize_field("sizeGib", &self.size_gib)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for PublicImageBlockDevice {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["device", "size_gib", "sizeGib"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Device,
            SizeGib,
            __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 {
                            "device" => Ok(GeneratedField::Device),
                            "sizeGib" | "size_gib" => Ok(GeneratedField::SizeGib),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = PublicImageBlockDevice;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.compute.v1beta1.PublicImageBlockDevice",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<PublicImageBlockDevice, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut device__ = None;
                let mut size_gib__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Device => {
                            if device__.is_some() {
                                return Err(serde::de::Error::duplicate_field("device"));
                            }
                            device__ = Some(map_.next_value()?);
                        }
                        GeneratedField::SizeGib => {
                            if size_gib__.is_some() {
                                return Err(serde::de::Error::duplicate_field("sizeGib"));
                            }
                            size_gib__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(PublicImageBlockDevice {
                    device: device__.unwrap_or_default(),
                    size_gib: size_gib__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.PublicImageBlockDevice",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for StartInstanceRequest {
    #[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.compute.v1beta1.StartInstanceRequest", 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 StartInstanceRequest {
    #[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 = StartInstanceRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.compute.v1beta1.StartInstanceRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<StartInstanceRequest, 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(StartInstanceRequest {
                    name: name__.unwrap_or_default(),
                    request_id: request_id__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.StartInstanceRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for StopInstanceRequest {
    #[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.compute.v1beta1.StopInstanceRequest", 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 StopInstanceRequest {
    #[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 = StopInstanceRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.compute.v1beta1.StopInstanceRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<StopInstanceRequest, 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(StopInstanceRequest {
                    name: name__.unwrap_or_default(),
                    request_id: request_id__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.StopInstanceRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for UpdateImageRequest {
    #[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.image.is_some() {
            len += 1;
        }
        if self.update_mask.is_some() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.compute.v1beta1.UpdateImageRequest", len)?;
        if let Some(v) = self.image.as_ref() {
            struct_ser.serialize_field("image", 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 UpdateImageRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["image", "update_mask", "updateMask"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Image,
            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 {
                            "image" => Ok(GeneratedField::Image),
                            "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 = UpdateImageRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.compute.v1beta1.UpdateImageRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<UpdateImageRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut image__ = None;
                let mut update_mask__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Image => {
                            if image__.is_some() {
                                return Err(serde::de::Error::duplicate_field("image"));
                            }
                            image__ = 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(UpdateImageRequest {
                    image: image__,
                    update_mask: update_mask__,
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.UpdateImageRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for UpdateInstanceRequest {
    #[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.instance.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.compute.v1beta1.UpdateInstanceRequest", len)?;
        if let Some(v) = self.instance.as_ref() {
            struct_ser.serialize_field("instance", 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 UpdateInstanceRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "instance",
            "update_mask",
            "updateMask",
            "request_id",
            "requestId",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Instance,
            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 {
                            "instance" => Ok(GeneratedField::Instance),
                            "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 = UpdateInstanceRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.compute.v1beta1.UpdateInstanceRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<UpdateInstanceRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut instance__ = None;
                let mut update_mask__ = None;
                let mut request_id__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Instance => {
                            if instance__.is_some() {
                                return Err(serde::de::Error::duplicate_field("instance"));
                            }
                            instance__ = 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(UpdateInstanceRequest {
                    instance: instance__,
                    update_mask: update_mask__,
                    request_id: request_id__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.UpdateInstanceRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for UpdateKeyPairRequest {
    #[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.key_pair.is_some() {
            len += 1;
        }
        if self.update_mask.is_some() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.compute.v1beta1.UpdateKeyPairRequest", len)?;
        if let Some(v) = self.key_pair.as_ref() {
            struct_ser.serialize_field("keyPair", 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 UpdateKeyPairRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["key_pair", "keyPair", "update_mask", "updateMask"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            KeyPair,
            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 {
                            "keyPair" | "key_pair" => Ok(GeneratedField::KeyPair),
                            "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 = UpdateKeyPairRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.compute.v1beta1.UpdateKeyPairRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<UpdateKeyPairRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut key_pair__ = None;
                let mut update_mask__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::KeyPair => {
                            if key_pair__.is_some() {
                                return Err(serde::de::Error::duplicate_field("keyPair"));
                            }
                            key_pair__ = 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(UpdateKeyPairRequest {
                    key_pair: key_pair__,
                    update_mask: update_mask__,
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.UpdateKeyPairRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for VolumeAttachment {
    #[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.volume.is_empty() {
            len += 1;
        }
        if !self.device.is_empty() {
            len += 1;
        }
        if self.boot {
            len += 1;
        }
        if self.state != 0 {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.compute.v1beta1.VolumeAttachment", 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.volume.is_empty() {
            struct_ser.serialize_field("volume", &self.volume)?;
        }
        if !self.device.is_empty() {
            struct_ser.serialize_field("device", &self.device)?;
        }
        if self.boot {
            struct_ser.serialize_field("boot", &self.boot)?;
        }
        if self.state != 0 {
            let v = volume_attachment::State::try_from(self.state)
                .map_err(|_| serde::ser::Error::custom(
                    format!("Invalid variant {}", self.state),
                ))?;
            struct_ser.serialize_field("state", &v)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for VolumeAttachment {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["name", "urn", "volume", "device", "boot", "state"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            Urn,
            Volume,
            Device,
            Boot,
            State,
            __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),
                            "volume" => Ok(GeneratedField::Volume),
                            "device" => Ok(GeneratedField::Device),
                            "boot" => Ok(GeneratedField::Boot),
                            "state" => Ok(GeneratedField::State),
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = VolumeAttachment;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.compute.v1beta1.VolumeAttachment")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<VolumeAttachment, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                let mut urn__ = None;
                let mut volume__ = None;
                let mut device__ = None;
                let mut boot__ = None;
                let mut state__ = 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::Volume => {
                            if volume__.is_some() {
                                return Err(serde::de::Error::duplicate_field("volume"));
                            }
                            volume__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Device => {
                            if device__.is_some() {
                                return Err(serde::de::Error::duplicate_field("device"));
                            }
                            device__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Boot => {
                            if boot__.is_some() {
                                return Err(serde::de::Error::duplicate_field("boot"));
                            }
                            boot__ = Some(map_.next_value()?);
                        }
                        GeneratedField::State => {
                            if state__.is_some() {
                                return Err(serde::de::Error::duplicate_field("state"));
                            }
                            state__ = Some(
                                map_.next_value::<volume_attachment::State>()? as i32,
                            );
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(VolumeAttachment {
                    name: name__.unwrap_or_default(),
                    urn: urn__.unwrap_or_default(),
                    volume: volume__.unwrap_or_default(),
                    device: device__.unwrap_or_default(),
                    boot: boot__.unwrap_or_default(),
                    state: state__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.compute.v1beta1.VolumeAttachment",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for volume_attachment::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::Creating => "CREATING",
            Self::Attaching => "ATTACHING",
            Self::Attached => "ATTACHED",
            Self::Detaching => "DETACHING",
            Self::Releasing => "RELEASING",
            Self::ReleaseAbandoned => "RELEASE_ABANDONED",
            Self::Failed => "FAILED",
        };
        serializer.serialize_str(variant)
    }
}
impl<'de> serde::Deserialize<'de> for volume_attachment::State {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "STATE_UNSPECIFIED",
            "CREATING",
            "ATTACHING",
            "ATTACHED",
            "DETACHING",
            "RELEASING",
            "RELEASE_ABANDONED",
            "FAILED",
        ];
        struct GeneratedVisitor;
        impl serde::de::Visitor<'_> for GeneratedVisitor {
            type Value = volume_attachment::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(volume_attachment::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(volume_attachment::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(volume_attachment::State::Unspecified),
                    "CREATING" => Ok(volume_attachment::State::Creating),
                    "ATTACHING" => Ok(volume_attachment::State::Attaching),
                    "ATTACHED" => Ok(volume_attachment::State::Attached),
                    "DETACHING" => Ok(volume_attachment::State::Detaching),
                    "RELEASING" => Ok(volume_attachment::State::Releasing),
                    "RELEASE_ABANDONED" => Ok(volume_attachment::State::ReleaseAbandoned),
                    "FAILED" => Ok(volume_attachment::State::Failed),
                    _ => Ok(volume_attachment::State::default()),
                }
            }
        }
        deserializer.deserialize_any(GeneratedVisitor)
    }
}
/// Calls `InstanceTypeService`.
///
/// The catalog of instance types: every size the platform publishes, each
/// saying whether an instance can be launched as it right now. Not scoped to
/// an organisation or a project; no permission is needed.
#[derive(Clone, Debug)]
pub struct InstanceTypeClient {
    service: ::origincloud_core::Service,
}
impl InstanceTypeClient {
    /// Returns a client of `InstanceTypeService` that sends its calls through `client`.
    pub fn new(client: &::origincloud_core::Client) -> Self {
        Self {
            service: client.service("compute", true),
        }
    }
    /// The endpoint the client sends its calls to, which also serves the operations its methods answer with.
    pub fn service(&self) -> &::origincloud_core::Service {
        &self.service
    }
    /// Returns an instance type.
    pub async fn get_instance_type(
        &self,
        request: GetInstanceTypeRequest,
    ) -> ::core::result::Result<InstanceType, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "name",
            &request.name,
            "instanceTypes/*",
        )?;
        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 every instance type, including those no longer offered, which
    /// instances launched as them still report: check `available` before
    /// launching as one.
    pub async fn list_instance_types(
        &self,
        request: ListInstanceTypesRequest,
    ) -> ::core::result::Result<ListInstanceTypesResponse, ::origincloud_core::Error> {
        let query = ::origincloud_core::query(&request, &[])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::GET,
                ::std::string::String::from("/v1beta1/instanceTypes"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
}
/// Calls `ImageFamilyService`.
///
/// The catalog of image families: stable names that each launch whichever
/// public image is current for them, so a launch gets the latest build
/// without naming an image. Not scoped to an organisation or a project; no
/// permission is needed.
#[derive(Clone, Debug)]
pub struct ImageFamilyClient {
    service: ::origincloud_core::Service,
}
impl ImageFamilyClient {
    /// Returns a client of `ImageFamilyService` that sends its calls through `client`.
    pub fn new(client: &::origincloud_core::Client) -> Self {
        Self {
            service: client.service("compute", true),
        }
    }
    /// The endpoint the client sends its calls to, which also serves the operations its methods answer with.
    pub fn service(&self) -> &::origincloud_core::Service {
        &self.service
    }
    /// Returns an image family.
    pub async fn get_image_family(
        &self,
        request: GetImageFamilyRequest,
    ) -> ::core::result::Result<ImageFamily, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "name",
            &request.name,
            "imageFamilies/*",
        )?;
        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 every image family, including those no longer offered: check
    /// `available` before launching from one.
    pub async fn list_image_families(
        &self,
        request: ListImageFamiliesRequest,
    ) -> ::core::result::Result<ListImageFamiliesResponse, ::origincloud_core::Error> {
        let query = ::origincloud_core::query(&request, &[])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::GET,
                ::std::string::String::from("/v1beta1/imageFamilies"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
}
/// Calls `ImageService`.
///
/// Images: what an instance's boot volume is created from, in one zone. A
/// project creates its own from protected snapshots in the zone; the
/// platform's public images are in `PublicImageService`.
#[derive(Clone, Debug)]
pub struct ImageClient {
    service: ::origincloud_core::Service,
}
impl ImageClient {
    /// Returns a client of `ImageService` that sends its calls through `client`.
    pub fn new(client: &::origincloud_core::Client) -> Self {
        Self {
            service: client.service("compute", true),
        }
    }
    /// 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 one of the project's own images.
    pub async fn get_image(
        &self,
        request: GetImageRequest,
    ) -> ::core::result::Result<Image, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "name",
            &request.name,
            "projects/*/zones/*/images/*",
        )?;
        let query = ::origincloud_core::query(&request, &["name"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::GET,
                format!("/v1beta1/{p0}"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Lists the project's own images in a zone, oldest first. The public
    /// images are listed by `ListPublicImages`.
    pub async fn list_images(
        &self,
        request: ListImagesRequest,
    ) -> ::core::result::Result<ListImagesResponse, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "parent",
            &request.parent,
            "projects/*/zones/*",
        )?;
        let query = ::origincloud_core::query(&request, &["parent"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::GET,
                format!("/v1beta1/{p0}/images"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Returns everything [`list_images`](Self::list_images) 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_images(
        &self,
        request: ListImagesRequest,
    ) -> ::origincloud_core::Pages<Image> {
        let client = self.clone();
        ::origincloud_core::Pages::new(
            request,
            move |request: ListImagesRequest| {
                let client = client.clone();
                async move {
                    let page = client.list_images(request).await?;
                    Ok((page.images, page.next_page_token))
                }
            },
            |request: &mut ListImagesRequest, token: ::std::string::String| {
                request.page_token = token;
            },
        )
    }
    /// Creates an image from the project's protected snapshots in the zone.
    /// The snapshots can't be unprotected while the image exists.
    pub async fn create_image(
        &self,
        mut request: CreateImageRequest,
    ) -> ::core::result::Result<Image, ::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/*/zones/*",
        )?;
        let body = ::origincloud_core::json_body(
            request.image.as_ref().unwrap_or(&::core::default::Default::default()),
        )?;
        let query = ::origincloud_core::query(&request, &["parent", "image"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::POST,
                format!("/v1beta1/{p0}/images"),
            )
            .with_body(body)
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Changes an image's description or tags.
    pub async fn update_image(
        &self,
        request: UpdateImageRequest,
    ) -> ::core::result::Result<Image, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "image.name",
            request.image.as_ref().map_or("", |m| m.name.as_str()),
            "projects/*/zones/*/images/*",
        )?;
        let body = ::origincloud_core::json_body(
            request.image.as_ref().unwrap_or(&::core::default::Default::default()),
        )?;
        let query = ::origincloud_core::query(&request, &["image.name", "image"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::PATCH,
                format!("/v1beta1/{p0}"),
            )
            .with_body(body)
            .with_query(query);
        self.service.call(call).await
    }
    /// Deletes an image. Instances launched from it are unaffected.
    pub async fn delete_image(
        &self,
        request: DeleteImageRequest,
    ) -> ::core::result::Result<
        ::origincloud_core::protobuf::Empty,
        ::origincloud_core::Error,
    > {
        let p0 = ::origincloud_core::path_value(
            "name",
            &request.name,
            "projects/*/zones/*/images/*",
        )?;
        let query = ::origincloud_core::query(&request, &["name"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::DELETE,
                format!("/v1beta1/{p0}"),
            )
            .with_query(query);
        self.service.call(call).await
    }
}
/// Calls `InstanceService`.
///
/// Instances: virtual machines in one zone, booted from an image onto a
/// durable boot volume, with network interfaces created beforehand with the
/// network service.
#[derive(Clone, Debug)]
pub struct InstanceClient {
    service: ::origincloud_core::Service,
}
impl InstanceClient {
    /// Returns a client of `InstanceService` that sends its calls through `client`.
    pub fn new(client: &::origincloud_core::Client) -> Self {
        Self {
            service: client.service("compute", true),
        }
    }
    /// The endpoint the client sends its calls to, which also serves the operations its methods answer with.
    pub fn service(&self) -> &::origincloud_core::Service {
        &self.service
    }
    /// Returns an instance. A terminated instance can be read by name for a
    /// day after it was terminated.
    pub async fn get_instance(
        &self,
        request: GetInstanceRequest,
    ) -> ::core::result::Result<Instance, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "name",
            &request.name,
            "projects/*/zones/*/instances/*",
        )?;
        let query = ::origincloud_core::query(&request, &["name"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::GET,
                format!("/v1beta1/{p0}"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Lists the instances in a zone, oldest first. A terminated instance is
    /// listed for two hours after it was terminated. For every zone's
    /// instances, list the zones whose `services` name `compute` with the
    /// location service (`location.origincloudapis.eu`), then each zone's
    /// instances.
    pub async fn list_instances(
        &self,
        request: ListInstancesRequest,
    ) -> ::core::result::Result<ListInstancesResponse, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "parent",
            &request.parent,
            "projects/*/zones/*",
        )?;
        let query = ::origincloud_core::query(&request, &["parent"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::GET,
                format!("/v1beta1/{p0}/instances"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Returns everything [`list_instances`](Self::list_instances) 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_instances(
        &self,
        request: ListInstancesRequest,
    ) -> ::origincloud_core::Pages<Instance> {
        let client = self.clone();
        ::origincloud_core::Pages::new(
            request,
            move |request: ListInstancesRequest| {
                let client = client.clone();
                async move {
                    let page = client.list_instances(request).await?;
                    Ok((page.instances, page.next_page_token))
                }
            },
            |request: &mut ListInstancesRequest, token: ::std::string::String| {
                request.page_token = token;
            },
        )
    }
    /// Launches an instance. The operation is done once the instance is
    /// `instance::State::Running`, or failed once it is `instance::State::Failed`, with the reason in
    /// `state_reason`; a failed instance still exists, and can be started
    /// again or deleted.
    ///
    /// It answers with an operation to wait on: [`Operation::wait`](origincloud_core::Operation::wait) returns the [`Instance`] once the change is done.
    pub async fn create_instance(
        &self,
        mut request: CreateInstanceRequest,
    ) -> ::core::result::Result<
        ::origincloud_core::Operation<Instance>,
        ::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/*/zones/*",
        )?;
        let body = ::origincloud_core::json_body(
            request.instance.as_ref().unwrap_or(&::core::default::Default::default()),
        )?;
        let query = ::origincloud_core::query(&request, &["parent", "instance"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::POST,
                format!("/v1beta1/{p0}/instances"),
            )
            .with_body(body)
            .with_query(query)
            .idempotent();
        let operation = self.service.call(call).await?;
        Ok(
            ::origincloud_core::Operation::new(
                self.service.clone(),
                operation,
                "origincloud.compute.v1beta1.Instance",
            ),
        )
    }
    /// Changes an instance's type or tags. A new `instance_type` needs the
    /// instance `instance::State::Stopped`, and is refused with `FAILED_PRECONDITION`
    /// otherwise; it takes effect at the next start. A larger type is checked
    /// against the same vCPU quota a launch is. The operation is done once the
    /// instance shows the change.
    ///
    /// It answers with an operation to wait on: [`Operation::wait`](origincloud_core::Operation::wait) returns the [`Instance`] once the change is done.
    pub async fn update_instance(
        &self,
        mut request: UpdateInstanceRequest,
    ) -> ::core::result::Result<
        ::origincloud_core::Operation<Instance>,
        ::origincloud_core::Error,
    > {
        if request.request_id.is_empty() {
            request.request_id = ::origincloud_core::new_request_id();
        }
        let p0 = ::origincloud_core::path_value(
            "instance.name",
            request.instance.as_ref().map_or("", |m| m.name.as_str()),
            "projects/*/zones/*/instances/*",
        )?;
        let body = ::origincloud_core::json_body(
            request.instance.as_ref().unwrap_or(&::core::default::Default::default()),
        )?;
        let query = ::origincloud_core::query(&request, &["instance.name", "instance"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::PATCH,
                format!("/v1beta1/{p0}"),
            )
            .with_body(body)
            .with_query(query)
            .idempotent();
        let operation = self.service.call(call).await?;
        Ok(
            ::origincloud_core::Operation::new(
                self.service.clone(),
                operation,
                "origincloud.compute.v1beta1.Instance",
            ),
        )
    }
    /// Terminates an instance: its guest is stopped for good, its network
    /// interfaces are released, `AVAILABLE` again with their addresses (one
    /// created for it at launch is deleted), and
    /// its boot volume is deleted with it unless a snapshot of it exists.
    /// Other attached volumes are detached and kept.
    /// Terminating a terminated instance changes nothing. The operation is
    /// done once the instance is `instance::State::Terminated`.
    ///
    /// It answers with an operation to wait on, which has no result: [`Operation::wait`](origincloud_core::Operation::wait) returns once the change is done.
    pub async fn delete_instance(
        &self,
        mut request: DeleteInstanceRequest,
    ) -> ::core::result::Result<
        ::origincloud_core::Operation<::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/*/zones/*/instances/*",
        )?;
        let query = ::origincloud_core::query(&request, &["name"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::DELETE,
                format!("/v1beta1/{p0}"),
            )
            .with_query(query)
            .idempotent();
        let operation = self.service.call(call).await?;
        Ok(
            ::origincloud_core::Operation::new(
                self.service.clone(),
                operation,
                "google.protobuf.Empty",
            ),
        )
    }
    /// Starts a `instance::State::Stopped` or `instance::State::Failed` instance. It keeps its name, its
    /// addresses and its volumes, and may come back on another machine.
    /// Starting a running instance changes nothing; it is refused while the
    /// instance is `instance::State::Initializing`, `instance::State::Stopping` or `instance::State::ShuttingDown`. The
    /// operation is done once the instance is `instance::State::Running`, or failed once it is
    /// `instance::State::Failed`.
    ///
    /// It answers with an operation to wait on: [`Operation::wait`](origincloud_core::Operation::wait) returns the [`Instance`] once the change is done.
    pub async fn start_instance(
        &self,
        mut request: StartInstanceRequest,
    ) -> ::core::result::Result<
        ::origincloud_core::Operation<Instance>,
        ::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/*/zones/*/instances/*",
        )?;
        let body = ::origincloud_core::json_body(&request)?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::POST,
                format!("/v1beta1/{p0}:start"),
            )
            .with_body(body)
            .idempotent();
        let operation = self.service.call(call).await?;
        Ok(
            ::origincloud_core::Operation::new(
                self.service.clone(),
                operation,
                "origincloud.compute.v1beta1.Instance",
            ),
        )
    }
    /// Stops a running instance: its guest is shut down, and it keeps its
    /// volumes and addresses. Stopping a stopped instance changes nothing. The
    /// operation is done once the instance is `instance::State::Stopped`, or failed once it is
    /// `instance::State::Failed`.
    ///
    /// It answers with an operation to wait on: [`Operation::wait`](origincloud_core::Operation::wait) returns the [`Instance`] once the change is done.
    pub async fn stop_instance(
        &self,
        mut request: StopInstanceRequest,
    ) -> ::core::result::Result<
        ::origincloud_core::Operation<Instance>,
        ::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/*/zones/*/instances/*",
        )?;
        let body = ::origincloud_core::json_body(&request)?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::POST,
                format!("/v1beta1/{p0}:stop"),
            )
            .with_body(body)
            .idempotent();
        let operation = self.service.call(call).await?;
        Ok(
            ::origincloud_core::Operation::new(
                self.service.clone(),
                operation,
                "origincloud.compute.v1beta1.Instance",
            ),
        )
    }
}
/// Calls `KeyPairService`.
///
/// Key pairs: SSH public keys an instance installs for its login user at
/// launch. A key pair belongs to its project and can be used in every zone.
/// Import a key you have, or have the platform generate one and return its
/// private key once.
#[derive(Clone, Debug)]
pub struct KeyPairClient {
    service: ::origincloud_core::Service,
}
impl KeyPairClient {
    /// Returns a client of `KeyPairService` that sends its calls through `client`.
    pub fn new(client: &::origincloud_core::Client) -> Self {
        Self {
            service: client.service("compute", true),
        }
    }
    /// 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 key pair, its public key only.
    pub async fn get_key_pair(
        &self,
        request: GetKeyPairRequest,
    ) -> ::core::result::Result<KeyPair, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "name",
            &request.name,
            "projects/*/keyPairs/*",
        )?;
        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 key pairs, oldest first.
    pub async fn list_key_pairs(
        &self,
        request: ListKeyPairsRequest,
    ) -> ::core::result::Result<ListKeyPairsResponse, ::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}/keyPairs"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Returns everything [`list_key_pairs`](Self::list_key_pairs) 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_key_pairs(
        &self,
        request: ListKeyPairsRequest,
    ) -> ::origincloud_core::Pages<KeyPair> {
        let client = self.clone();
        ::origincloud_core::Pages::new(
            request,
            move |request: ListKeyPairsRequest| {
                let client = client.clone();
                async move {
                    let page = client.list_key_pairs(request).await?;
                    Ok((page.key_pairs, page.next_page_token))
                }
            },
            |request: &mut ListKeyPairsRequest, token: ::std::string::String| {
                request.page_token = token;
            },
        )
    }
    /// Creates a key pair: imports `public_key`, or, left empty, generates an
    /// `ssh-ed25519` key and returns its private half in `private_key`, in
    /// this response only. A repeat of a generating request with the same
    /// `request_id` can't return the private key again, and is refused with
    /// `CONFLICT`, its `ErrorInfo` metadata naming the key pair under
    /// `keyPair`: delete it and create another.
    pub async fn create_key_pair(
        &self,
        mut request: CreateKeyPairRequest,
    ) -> ::core::result::Result<KeyPair, ::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.key_pair.as_ref().unwrap_or(&::core::default::Default::default()),
        )?;
        let query = ::origincloud_core::query(&request, &["parent", "keyPair"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::POST,
                format!("/v1beta1/{p0}/keyPairs"),
            )
            .with_body(body)
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Changes a key pair's tags.
    pub async fn update_key_pair(
        &self,
        request: UpdateKeyPairRequest,
    ) -> ::core::result::Result<KeyPair, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "keyPair.name",
            request.key_pair.as_ref().map_or("", |m| m.name.as_str()),
            "projects/*/keyPairs/*",
        )?;
        let body = ::origincloud_core::json_body(
            request.key_pair.as_ref().unwrap_or(&::core::default::Default::default()),
        )?;
        let query = ::origincloud_core::query(&request, &["keyPair.name", "keyPair"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::PATCH,
                format!("/v1beta1/{p0}"),
            )
            .with_body(body)
            .with_query(query);
        self.service.call(call).await
    }
    /// Deletes a key pair. Instances launched with it keep the key installed.
    pub async fn delete_key_pair(
        &self,
        request: DeleteKeyPairRequest,
    ) -> ::core::result::Result<
        ::origincloud_core::protobuf::Empty,
        ::origincloud_core::Error,
    > {
        let p0 = ::origincloud_core::path_value(
            "name",
            &request.name,
            "projects/*/keyPairs/*",
        )?;
        let query = ::origincloud_core::query(&request, &["name"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::DELETE,
                format!("/v1beta1/{p0}"),
            )
            .with_query(query);
        self.service.call(call).await
    }
}
/// Calls `PublicImageService`.
///
/// The catalog of public images: the platform's images, in each zone, that
/// any project's instances can be launched from. Not scoped to an
/// organisation or a project; no permission is needed.
#[derive(Clone, Debug)]
pub struct PublicImageClient {
    service: ::origincloud_core::Service,
}
impl PublicImageClient {
    /// Returns a client of `PublicImageService` that sends its calls through `client`.
    pub fn new(client: &::origincloud_core::Client) -> Self {
        Self {
            service: client.service("compute", true),
        }
    }
    /// 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 public image.
    pub async fn get_public_image(
        &self,
        request: GetPublicImageRequest,
    ) -> ::core::result::Result<PublicImage, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "name",
            &request.name,
            "zones/*/images/*",
        )?;
        let query = ::origincloud_core::query(&request, &["name"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::GET,
                format!("/v1beta1/{p0}"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Lists the public images in a zone, oldest first.
    pub async fn list_public_images(
        &self,
        request: ListPublicImagesRequest,
    ) -> ::core::result::Result<ListPublicImagesResponse, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value("parent", &request.parent, "zones/*")?;
        let query = ::origincloud_core::query(&request, &["parent"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::GET,
                format!("/v1beta1/{p0}/images"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Returns everything [`list_public_images`](Self::list_public_images) 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_public_images(
        &self,
        request: ListPublicImagesRequest,
    ) -> ::origincloud_core::Pages<PublicImage> {
        let client = self.clone();
        ::origincloud_core::Pages::new(
            request,
            move |request: ListPublicImagesRequest| {
                let client = client.clone();
                async move {
                    let page = client.list_public_images(request).await?;
                    Ok((page.public_images, page.next_page_token))
                }
            },
            |request: &mut ListPublicImagesRequest, token: ::std::string::String| {
                request.page_token = token;
            },
        )
    }
}
/// Calls `VolumeAttachmentService`.
///
/// Volume attachments: which volumes of the persistent volume service an
/// instance holds, and the device names its guest sees them under. Creating
/// one attaches a volume, deleting it detaches the volume.
#[derive(Clone, Debug)]
pub struct VolumeAttachmentClient {
    service: ::origincloud_core::Service,
}
impl VolumeAttachmentClient {
    /// Returns a client of `VolumeAttachmentService` that sends its calls through `client`.
    pub fn new(client: &::origincloud_core::Client) -> Self {
        Self {
            service: client.service("compute", true),
        }
    }
    /// 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 volume attachment. A detached attachment isn't found.
    pub async fn get_volume_attachment(
        &self,
        request: GetVolumeAttachmentRequest,
    ) -> ::core::result::Result<VolumeAttachment, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "name",
            &request.name,
            "projects/*/zones/*/instances/*/volumeAttachments/*",
        )?;
        let query = ::origincloud_core::query(&request, &["name"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::GET,
                format!("/v1beta1/{p0}"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Lists an instance's volume attachments, the boot volume's first, then
    /// by device name. With `-` for the instance, lists every instance's in the
    /// zone, which with `volume` finds the instance holding a volume.
    /// Detached attachments aren't listed.
    pub async fn list_volume_attachments(
        &self,
        request: ListVolumeAttachmentsRequest,
    ) -> ::core::result::Result<
        ListVolumeAttachmentsResponse,
        ::origincloud_core::Error,
    > {
        let p0 = ::origincloud_core::path_value(
            "parent",
            &request.parent,
            "projects/*/zones/*/instances/*",
        )?;
        let query = ::origincloud_core::query(&request, &["parent"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::GET,
                format!("/v1beta1/{p0}/volumeAttachments"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Returns everything [`list_volume_attachments`](Self::list_volume_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_volume_attachments(
        &self,
        request: ListVolumeAttachmentsRequest,
    ) -> ::origincloud_core::Pages<VolumeAttachment> {
        let client = self.clone();
        ::origincloud_core::Pages::new(
            request,
            move |request: ListVolumeAttachmentsRequest| {
                let client = client.clone();
                async move {
                    let page = client.list_volume_attachments(request).await?;
                    Ok((page.volume_attachments, page.next_page_token))
                }
            },
            |request: &mut ListVolumeAttachmentsRequest, token: ::std::string::String| {
                request.page_token = token;
            },
        )
    }
    /// Attaches an `AVAILABLE` volume to a `instance::State::Running` or `instance::State::Stopped` instance in
    /// the same project and zone. On a stopped instance the disk appears at
    /// the next start, and the operation is done at once. On a running one it
    /// is added live, and the operation is done once the guest sees it, or
    /// failed if it couldn't be added, which leaves the volume available.
    ///
    /// It answers with an operation to wait on: [`Operation::wait`](origincloud_core::Operation::wait) returns the [`VolumeAttachment`] once the change is done.
    pub async fn create_volume_attachment(
        &self,
        mut request: CreateVolumeAttachmentRequest,
    ) -> ::core::result::Result<
        ::origincloud_core::Operation<VolumeAttachment>,
        ::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/*/zones/*/instances/*",
        )?;
        let body = ::origincloud_core::json_body(
            request
                .volume_attachment
                .as_ref()
                .unwrap_or(&::core::default::Default::default()),
        )?;
        let query = ::origincloud_core::query(
            &request,
            &["parent", "volumeAttachment"],
        )?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::POST,
                format!("/v1beta1/{p0}/volumeAttachments"),
            )
            .with_body(body)
            .with_query(query)
            .idempotent();
        let operation = self.service.call(call).await?;
        Ok(
            ::origincloud_core::Operation::new(
                self.service.clone(),
                operation,
                "origincloud.compute.v1beta1.VolumeAttachment",
            ),
        )
    }
    /// Detaches a volume, which then is `AVAILABLE` again. The boot volume
    /// can't be detached. On a running instance the device is removed live;
    /// if the guest doesn't release it, the operation fails and the volume
    /// stays attached. The operation is done once the volume is detached.
    ///
    /// It answers with an operation to wait on, which has no result: [`Operation::wait`](origincloud_core::Operation::wait) returns once the change is done.
    pub async fn delete_volume_attachment(
        &self,
        mut request: DeleteVolumeAttachmentRequest,
    ) -> ::core::result::Result<
        ::origincloud_core::Operation<::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/*/zones/*/instances/*/volumeAttachments/*",
        )?;
        let query = ::origincloud_core::query(&request, &["name"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::DELETE,
                format!("/v1beta1/{p0}"),
            )
            .with_query(query)
            .idempotent();
        let operation = self.service.call(call).await?;
        Ok(
            ::origincloud_core::Operation::new(
                self.service.clone(),
                operation,
                "google.protobuf.Empty",
            ),
        )
    }
}