origincloud_pvs/generated/

origincloud.pvs.v1beta1.rs

// Code generated by origincloud-sdk-generator. DO NOT EDIT.
// source: origincloud/pvs/v1beta1/snapshot.proto
// source: origincloud/pvs/v1beta1/storage_class.proto
// source: origincloud/pvs/v1beta1/volume.proto

/// A point-in-time copy of a volume.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Snapshot {
    /// The snapshot's resource name.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The snapshot's URN, the identifier access policies and the audit log
    /// use.
    #[prost(string, tag = "2")]
    pub urn: ::prost::alloc::string::String,
    /// The volume copied, in the same project and zone.
    #[prost(string, tag = "3")]
    pub source_volume: ::prost::alloc::string::String,
    /// The source volume's size in GiB when it was copied: the least a volume
    /// created from the snapshot holds.
    #[prost(int32, tag = "4")]
    pub source_size_gib: i32,
    /// Where the copy is.
    #[prost(enumeration = "snapshot::State", tag = "5")]
    pub state: i32,
    /// Why the snapshot is in `snapshot::State::Error`; empty otherwise.
    #[prost(string, tag = "6")]
    pub state_reason: ::prost::alloc::string::String,
    /// Whether it is protected.
    #[prost(enumeration = "snapshot::ProtectionState", tag = "7")]
    pub protection_state: i32,
    /// Why the last protection change failed, when `protection_state` is
    /// `snapshot::ProtectionState::ProtectionFailed`.
    #[prost(string, tag = "8")]
    pub protection_reason: ::prost::alloc::string::String,
    /// The principal that took the snapshot, such as `user:<id>` or
    /// `service_account:<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 `Snapshot`.
pub mod snapshot {
    /// Where the copy is.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        /// Not set.
        Unspecified = 0,
        /// Being copied.
        Pending = 1,
        /// Copied.
        Completed = 2,
        /// Being deleted.
        Deleting = 3,
        /// Deleted. Readable by name for a day, never listed.
        Deleted = 4,
        /// The copy or its removal failed; `state_reason` says which. There is
        /// no usable copy behind it: delete it.
        Error = 5,
    }
    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::Pending => "PENDING",
                Self::Completed => "COMPLETED",
                Self::Deleting => "DELETING",
                Self::Deleted => "DELETED",
                Self::Error => "ERROR",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATE_UNSPECIFIED" => Some(Self::Unspecified),
                "PENDING" => Some(Self::Pending),
                "COMPLETED" => Some(Self::Completed),
                "DELETING" => Some(Self::Deleting),
                "DELETED" => Some(Self::Deleted),
                "ERROR" => Some(Self::Error),
                _ => None,
            }
        }
    }
    /// Whether the snapshot is protected, independently of `state`.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ProtectionState {
        /// Not set.
        Unspecified = 0,
        /// Not protected: it can be deleted, and is no source.
        Unprotected = 1,
        /// Becoming protected.
        Protecting = 2,
        /// Protected: a source of volumes and images, and can't be deleted.
        Protected = 3,
        /// Becoming unprotected.
        Unprotecting = 4,
        /// The last change couldn't be applied; `protection_reason` says why.
        /// Protect or unprotect it again.
        ProtectionFailed = 5,
    }
    impl ProtectionState {
        /// 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 => "PROTECTION_STATE_UNSPECIFIED",
                Self::Unprotected => "UNPROTECTED",
                Self::Protecting => "PROTECTING",
                Self::Protected => "PROTECTED",
                Self::Unprotecting => "UNPROTECTING",
                Self::ProtectionFailed => "PROTECTION_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 {
                "PROTECTION_STATE_UNSPECIFIED" => Some(Self::Unspecified),
                "UNPROTECTED" => Some(Self::Unprotected),
                "PROTECTING" => Some(Self::Protecting),
                "PROTECTED" => Some(Self::Protected),
                "UNPROTECTING" => Some(Self::Unprotecting),
                "PROTECTION_FAILED" => Some(Self::ProtectionFailed),
                _ => None,
            }
        }
    }
}
/// The request for GetSnapshot.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetSnapshotRequest {
    /// The snapshot to return.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request for ListSnapshots.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListSnapshotsRequest {
    /// The zone whose snapshots to list, `projects/{project}/zones/{zone}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The most snapshots 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 ListSnapshots.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListSnapshotsResponse {
    /// The snapshots on this page.
    #[prost(message, repeated, tag = "1")]
    pub snapshots: ::prost::alloc::vec::Vec<Snapshot>,
    /// 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 CreateSnapshot.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateSnapshotRequest {
    /// The zone of the volume to copy, `projects/{project}/zones/{zone}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The snapshot to take: its source volume, and optionally its tags.
    #[prost(message, optional, tag = "2")]
    pub snapshot: ::core::option::Option<Snapshot>,
    /// A UUID; a repeat with the same id returns the first request's
    /// operation instead of taking a second snapshot.
    #[prost(string, tag = "3")]
    pub request_id: ::prost::alloc::string::String,
}
/// The request for UpdateSnapshot.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateSnapshotRequest {
    /// The snapshot, by its name, with the tags to set.
    #[prost(message, optional, tag = "1")]
    pub snapshot: ::core::option::Option<Snapshot>,
    /// 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 DeleteSnapshot.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteSnapshotRequest {
    /// The snapshot to delete.
    #[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 ProtectSnapshot.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ProtectSnapshotRequest {
    /// The snapshot to protect; it must be `snapshot::State::Completed`.
    #[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 UnprotectSnapshot.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UnprotectSnapshotRequest {
    /// The snapshot to unprotect; it must be `snapshot::State::Completed`, or `snapshot::State::Error` so that
    /// it can then be deleted.
    #[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,
}
/// A storage tier a volume is created in.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct StorageClass {
    /// The class's resource name, `storageClasses/gp1`.
    #[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 media the class is backed by.
    #[prost(enumeration = "storage_class::Media", tag = "3")]
    pub media: i32,
    /// Whether a volume created without a storage class is created in this
    /// one.
    #[prost(bool, tag = "4")]
    pub default_class: bool,
    /// Whether the class can be selected right now. A class that is listed
    /// but not available is a published tier not yet on sale.
    #[prost(bool, tag = "5")]
    pub available: bool,
    /// The I/O operations per second a volume of the class is limited to; 0
    /// for a class not on sale.
    #[prost(int32, tag = "6")]
    pub baseline_iops: i32,
    /// The MiB per second a volume of the class is limited to; 0 for a class
    /// not on sale.
    #[prost(int32, tag = "7")]
    pub baseline_throughput_mibps: i32,
}
/// Nested message and enum types in `StorageClass`.
pub mod storage_class {
    /// The media a class is backed by.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Media {
        /// Not set.
        Unspecified = 0,
        /// Solid-state storage.
        Ssd = 1,
        /// Rotational (hard-disk) storage.
        Hdd = 2,
    }
    impl Media {
        /// 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 => "MEDIA_UNSPECIFIED",
                Self::Ssd => "SSD",
                Self::Hdd => "HDD",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "MEDIA_UNSPECIFIED" => Some(Self::Unspecified),
                "SSD" => Some(Self::Ssd),
                "HDD" => Some(Self::Hdd),
                _ => None,
            }
        }
    }
}
/// The request for GetStorageClass.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetStorageClassRequest {
    /// The class to return, `storageClasses/{storage_class}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request for ListStorageClasses. 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 ListStorageClassesRequest {}
/// The response for ListStorageClasses.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListStorageClassesResponse {
    /// Every storage class, in catalog order.
    #[prost(message, repeated, tag = "1")]
    pub storage_classes: ::prost::alloc::vec::Vec<StorageClass>,
}
/// A block storage volume in one zone.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Volume {
    /// The volume's resource name.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The volume's URN, the identifier access policies and the audit log
    /// use.
    #[prost(string, tag = "2")]
    pub urn: ::prost::alloc::string::String,
    /// The size in GiB, at least 1. Growing it resizes the volume; it never
    /// shrinks.
    #[prost(int32, tag = "3")]
    pub size_gib: i32,
    /// The storage class, `storageClasses/{storage_class}`. The default class
    /// when left empty.
    #[prost(string, tag = "4")]
    pub storage_class: ::prost::alloc::string::String,
    /// The snapshot the volume was created from, in the same project and
    /// zone; empty for an empty volume. The volume is at least the snapshot's
    /// size.
    #[prost(string, tag = "5")]
    pub source_snapshot: ::prost::alloc::string::String,
    /// Where the volume is in its lifecycle.
    #[prost(enumeration = "volume::State", tag = "6")]
    pub state: i32,
    /// Why the volume is in `volume::State::Error`; empty otherwise.
    #[prost(string, tag = "7")]
    pub state_reason: ::prost::alloc::string::String,
    /// When `state` is `volume::State::InUse`, the id of the volume attachment holding it.
    #[prost(string, tag = "8")]
    pub attachment: ::prost::alloc::string::String,
    /// Where the last resize is.
    #[prost(enumeration = "volume::ResizeState", tag = "9")]
    pub resize_state: i32,
    /// Why the last resize failed, when `resize_state` is `volume::ResizeState::ResizeFailed`.
    #[prost(string, tag = "10")]
    pub resize_reason: ::prost::alloc::string::String,
    /// The size a resize under way is heading for; 0 when none is.
    /// `size_gib` changes once the resize is confirmed.
    #[prost(int32, tag = "11")]
    pub pending_size_gib: i32,
    /// Why the volume is still here after the instance it was created with
    /// was terminated; empty in every other case. Most often a snapshot of it
    /// exists, and a snapshot depends on its volume's data.
    #[prost(string, tag = "12")]
    pub retention_note: ::prost::alloc::string::String,
    /// The most I/O operations per second the volume serves, reads and writes
    /// combined: a ceiling, not a guaranteed rate. 0 when it isn't limited.
    #[prost(int32, tag = "13")]
    pub iops: i32,
    /// The most MiB per second the volume transfers, reads and writes
    /// combined: a ceiling, not a guaranteed rate. 0 when it isn't limited.
    #[prost(int32, tag = "14")]
    pub throughput_mibps: i32,
    /// The principal that created the volume, such as `user:<id>` or
    /// `service_account:<id>`.
    #[prost(string, tag = "15")]
    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 = "16")]
    pub tags: ::prost::alloc::collections::BTreeMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
/// Nested message and enum types in `Volume`.
pub mod volume {
    /// Where the volume is in its lifecycle.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        /// Not set.
        Unspecified = 0,
        /// Being created.
        Creating = 1,
        /// Ready to attach.
        Available = 2,
        /// Attached to an instance.
        InUse = 3,
        /// Being deleted.
        Deleting = 4,
        /// Deleted. Readable by name for a day, never listed.
        Deleted = 5,
        /// Its storage couldn't be created or removed; `state_reason` says
        /// which. It can be deleted again.
        Error = 6,
    }
    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::Available => "AVAILABLE",
                Self::InUse => "IN_USE",
                Self::Deleting => "DELETING",
                Self::Deleted => "DELETED",
                Self::Error => "ERROR",
            }
        }
        /// 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),
                "AVAILABLE" => Some(Self::Available),
                "IN_USE" => Some(Self::InUse),
                "DELETING" => Some(Self::Deleting),
                "DELETED" => Some(Self::Deleted),
                "ERROR" => Some(Self::Error),
                _ => None,
            }
        }
    }
    /// Where a resize is.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ResizeState {
        /// Not set.
        Unspecified = 0,
        /// No resize is under way; the last one, if any, finished.
        ResizeCompleted = 1,
        /// Growing to `pending_size_gib`.
        Resizing = 2,
        /// The last resize failed; `resize_reason` says why. The volume and its
        /// data are unaffected.
        ResizeFailed = 3,
    }
    impl ResizeState {
        /// 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 => "RESIZE_STATE_UNSPECIFIED",
                Self::ResizeCompleted => "RESIZE_COMPLETED",
                Self::Resizing => "RESIZING",
                Self::ResizeFailed => "RESIZE_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 {
                "RESIZE_STATE_UNSPECIFIED" => Some(Self::Unspecified),
                "RESIZE_COMPLETED" => Some(Self::ResizeCompleted),
                "RESIZING" => Some(Self::Resizing),
                "RESIZE_FAILED" => Some(Self::ResizeFailed),
                _ => None,
            }
        }
    }
}
/// The request for GetVolume.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetVolumeRequest {
    /// The volume to return.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// The request for ListVolumes.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListVolumesRequest {
    /// The zone whose volumes to list, `projects/{project}/zones/{zone}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The most volumes 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 ListVolumes.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListVolumesResponse {
    /// The volumes on this page.
    #[prost(message, repeated, tag = "1")]
    pub volumes: ::prost::alloc::vec::Vec<Volume>,
    /// 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 CreateVolume.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateVolumeRequest {
    /// The zone to create the volume in, `projects/{project}/zones/{zone}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The volume to create: its size, and optionally its storage class,
    /// source snapshot and tags.
    #[prost(message, optional, tag = "2")]
    pub volume: ::core::option::Option<Volume>,
    /// A UUID; a repeat with the same id returns the first request's
    /// operation instead of creating a second volume.
    #[prost(string, tag = "3")]
    pub request_id: ::prost::alloc::string::String,
}
/// The request for ImportVolume.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ImportVolumeRequest {
    /// The zone to create the volume in, `projects/{project}/zones/{zone}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The volume to create: its size, which must hold the image, and
    /// optionally its storage class and tags.
    #[prost(message, optional, tag = "2")]
    pub volume: ::core::option::Option<Volume>,
    /// The URL of the disk image, which the platform downloads over HTTP or
    /// HTTPS: it must be reachable from the platform.
    #[prost(string, tag = "3")]
    pub source_url: ::prost::alloc::string::String,
    /// A UUID; a repeat with the same id returns the first request's
    /// operation instead of importing twice.
    #[prost(string, tag = "4")]
    pub request_id: ::prost::alloc::string::String,
}
/// The request for UpdateVolume.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateVolumeRequest {
    /// The volume, by its name, with the fields to change.
    #[prost(message, optional, tag = "1")]
    pub volume: ::core::option::Option<Volume>,
    /// The fields to change: `size_gib`, `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 volume again.
    #[prost(string, tag = "3")]
    pub request_id: ::prost::alloc::string::String,
}
/// The request for DeleteVolume.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteVolumeRequest {
    /// The volume to delete.
    #[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 CreateSnapshotRequest {
    #[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.snapshot.is_some() {
            len += 1;
        }
        if !self.request_id.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.pvs.v1beta1.CreateSnapshotRequest", len)?;
        if !self.parent.is_empty() {
            struct_ser.serialize_field("parent", &self.parent)?;
        }
        if let Some(v) = self.snapshot.as_ref() {
            struct_ser.serialize_field("snapshot", v)?;
        }
        if !self.request_id.is_empty() {
            struct_ser.serialize_field("requestId", &self.request_id)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for CreateSnapshotRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["parent", "snapshot", "request_id", "requestId"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Parent,
            Snapshot,
            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),
                            "snapshot" => Ok(GeneratedField::Snapshot),
                            "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 = CreateSnapshotRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.pvs.v1beta1.CreateSnapshotRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<CreateSnapshotRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut parent__ = None;
                let mut snapshot__ = 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::Snapshot => {
                            if snapshot__.is_some() {
                                return Err(serde::de::Error::duplicate_field("snapshot"));
                            }
                            snapshot__ = 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(CreateSnapshotRequest {
                    parent: parent__.unwrap_or_default(),
                    snapshot: snapshot__,
                    request_id: request_id__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.pvs.v1beta1.CreateSnapshotRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for CreateVolumeRequest {
    #[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.is_some() {
            len += 1;
        }
        if !self.request_id.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.pvs.v1beta1.CreateVolumeRequest", len)?;
        if !self.parent.is_empty() {
            struct_ser.serialize_field("parent", &self.parent)?;
        }
        if let Some(v) = self.volume.as_ref() {
            struct_ser.serialize_field("volume", v)?;
        }
        if !self.request_id.is_empty() {
            struct_ser.serialize_field("requestId", &self.request_id)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for CreateVolumeRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["parent", "volume", "request_id", "requestId"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Parent,
            Volume,
            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),
                            "volume" => Ok(GeneratedField::Volume),
                            "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 = CreateVolumeRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.pvs.v1beta1.CreateVolumeRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<CreateVolumeRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut parent__ = None;
                let mut volume__ = 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::Volume => {
                            if volume__.is_some() {
                                return Err(serde::de::Error::duplicate_field("volume"));
                            }
                            volume__ = 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(CreateVolumeRequest {
                    parent: parent__.unwrap_or_default(),
                    volume: volume__,
                    request_id: request_id__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.pvs.v1beta1.CreateVolumeRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for DeleteSnapshotRequest {
    #[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.pvs.v1beta1.DeleteSnapshotRequest", 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 DeleteSnapshotRequest {
    #[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 = DeleteSnapshotRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.pvs.v1beta1.DeleteSnapshotRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<DeleteSnapshotRequest, 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(DeleteSnapshotRequest {
                    name: name__.unwrap_or_default(),
                    request_id: request_id__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.pvs.v1beta1.DeleteSnapshotRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for DeleteVolumeRequest {
    #[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.pvs.v1beta1.DeleteVolumeRequest", 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 DeleteVolumeRequest {
    #[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 = DeleteVolumeRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.pvs.v1beta1.DeleteVolumeRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<DeleteVolumeRequest, 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(DeleteVolumeRequest {
                    name: name__.unwrap_or_default(),
                    request_id: request_id__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.pvs.v1beta1.DeleteVolumeRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for GetSnapshotRequest {
    #[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.pvs.v1beta1.GetSnapshotRequest", len)?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for GetSnapshotRequest {
    #[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 = GetSnapshotRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.pvs.v1beta1.GetSnapshotRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<GetSnapshotRequest, 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(GetSnapshotRequest {
                    name: name__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.pvs.v1beta1.GetSnapshotRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for GetStorageClassRequest {
    #[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.pvs.v1beta1.GetStorageClassRequest", len)?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for GetStorageClassRequest {
    #[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 = GetStorageClassRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.pvs.v1beta1.GetStorageClassRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<GetStorageClassRequest, 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(GetStorageClassRequest {
                    name: name__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.pvs.v1beta1.GetStorageClassRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for GetVolumeRequest {
    #[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.pvs.v1beta1.GetVolumeRequest", len)?;
        if !self.name.is_empty() {
            struct_ser.serialize_field("name", &self.name)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for GetVolumeRequest {
    #[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 = GetVolumeRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.pvs.v1beta1.GetVolumeRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<GetVolumeRequest, 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(GetVolumeRequest {
                    name: name__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.pvs.v1beta1.GetVolumeRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ImportVolumeRequest {
    #[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.is_some() {
            len += 1;
        }
        if !self.source_url.is_empty() {
            len += 1;
        }
        if !self.request_id.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.pvs.v1beta1.ImportVolumeRequest", len)?;
        if !self.parent.is_empty() {
            struct_ser.serialize_field("parent", &self.parent)?;
        }
        if let Some(v) = self.volume.as_ref() {
            struct_ser.serialize_field("volume", v)?;
        }
        if !self.source_url.is_empty() {
            struct_ser.serialize_field("sourceUrl", &self.source_url)?;
        }
        if !self.request_id.is_empty() {
            struct_ser.serialize_field("requestId", &self.request_id)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ImportVolumeRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "parent",
            "volume",
            "source_url",
            "sourceUrl",
            "request_id",
            "requestId",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Parent,
            Volume,
            SourceUrl,
            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),
                            "volume" => Ok(GeneratedField::Volume),
                            "sourceUrl" | "source_url" => Ok(GeneratedField::SourceUrl),
                            "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 = ImportVolumeRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.pvs.v1beta1.ImportVolumeRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ImportVolumeRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut parent__ = None;
                let mut volume__ = None;
                let mut source_url__ = 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::Volume => {
                            if volume__.is_some() {
                                return Err(serde::de::Error::duplicate_field("volume"));
                            }
                            volume__ = map_.next_value()?;
                        }
                        GeneratedField::SourceUrl => {
                            if source_url__.is_some() {
                                return Err(serde::de::Error::duplicate_field("sourceUrl"));
                            }
                            source_url__ = 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(ImportVolumeRequest {
                    parent: parent__.unwrap_or_default(),
                    volume: volume__,
                    source_url: source_url__.unwrap_or_default(),
                    request_id: request_id__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.pvs.v1beta1.ImportVolumeRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListSnapshotsRequest {
    #[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.pvs.v1beta1.ListSnapshotsRequest", 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 ListSnapshotsRequest {
    #[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 = ListSnapshotsRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.pvs.v1beta1.ListSnapshotsRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListSnapshotsRequest, 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(ListSnapshotsRequest {
                    parent: parent__.unwrap_or_default(),
                    page_size: page_size__.unwrap_or_default(),
                    page_token: page_token__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.pvs.v1beta1.ListSnapshotsRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListSnapshotsResponse {
    #[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.snapshots.is_empty() {
            len += 1;
        }
        if !self.next_page_token.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.pvs.v1beta1.ListSnapshotsResponse", len)?;
        if !self.snapshots.is_empty() {
            struct_ser.serialize_field("snapshots", &self.snapshots)?;
        }
        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 ListSnapshotsResponse {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["snapshots", "next_page_token", "nextPageToken"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Snapshots,
            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 {
                            "snapshots" => Ok(GeneratedField::Snapshots),
                            "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 = ListSnapshotsResponse;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.pvs.v1beta1.ListSnapshotsResponse")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListSnapshotsResponse, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut snapshots__ = None;
                let mut next_page_token__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Snapshots => {
                            if snapshots__.is_some() {
                                return Err(serde::de::Error::duplicate_field("snapshots"));
                            }
                            snapshots__ = 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(ListSnapshotsResponse {
                    snapshots: snapshots__.unwrap_or_default(),
                    next_page_token: next_page_token__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.pvs.v1beta1.ListSnapshotsResponse",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListStorageClassesRequest {
    #[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.pvs.v1beta1.ListStorageClassesRequest", len)?;
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ListStorageClassesRequest {
    #[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 = ListStorageClassesRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.pvs.v1beta1.ListStorageClassesRequest",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListStorageClassesRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                while map_.next_key::<GeneratedField>()?.is_some() {
                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                }
                Ok(ListStorageClassesRequest {})
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.pvs.v1beta1.ListStorageClassesRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListStorageClassesResponse {
    #[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.storage_classes.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct(
                "origincloud.pvs.v1beta1.ListStorageClassesResponse",
                len,
            )?;
        if !self.storage_classes.is_empty() {
            struct_ser.serialize_field("storageClasses", &self.storage_classes)?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for ListStorageClassesResponse {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["storage_classes", "storageClasses"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            StorageClasses,
            __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 {
                            "storageClasses" | "storage_classes" => {
                                Ok(GeneratedField::StorageClasses)
                            }
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = ListStorageClassesResponse;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str(
                        "struct origincloud.pvs.v1beta1.ListStorageClassesResponse",
                    )
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListStorageClassesResponse, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut storage_classes__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::StorageClasses => {
                            if storage_classes__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("storageClasses"),
                                );
                            }
                            storage_classes__ = Some(map_.next_value()?);
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(ListStorageClassesResponse {
                    storage_classes: storage_classes__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.pvs.v1beta1.ListStorageClassesResponse",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListVolumesRequest {
    #[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.pvs.v1beta1.ListVolumesRequest", 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 ListVolumesRequest {
    #[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 = ListVolumesRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.pvs.v1beta1.ListVolumesRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListVolumesRequest, 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(ListVolumesRequest {
                    parent: parent__.unwrap_or_default(),
                    page_size: page_size__.unwrap_or_default(),
                    page_token: page_token__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.pvs.v1beta1.ListVolumesRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ListVolumesResponse {
    #[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.volumes.is_empty() {
            len += 1;
        }
        if !self.next_page_token.is_empty() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.pvs.v1beta1.ListVolumesResponse", len)?;
        if !self.volumes.is_empty() {
            struct_ser.serialize_field("volumes", &self.volumes)?;
        }
        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 ListVolumesResponse {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["volumes", "next_page_token", "nextPageToken"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Volumes,
            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 {
                            "volumes" => Ok(GeneratedField::Volumes),
                            "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 = ListVolumesResponse;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.pvs.v1beta1.ListVolumesResponse")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ListVolumesResponse, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut volumes__ = None;
                let mut next_page_token__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Volumes => {
                            if volumes__.is_some() {
                                return Err(serde::de::Error::duplicate_field("volumes"));
                            }
                            volumes__ = 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(ListVolumesResponse {
                    volumes: volumes__.unwrap_or_default(),
                    next_page_token: next_page_token__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.pvs.v1beta1.ListVolumesResponse",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for ProtectSnapshotRequest {
    #[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.pvs.v1beta1.ProtectSnapshotRequest", 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 ProtectSnapshotRequest {
    #[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 = ProtectSnapshotRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.pvs.v1beta1.ProtectSnapshotRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<ProtectSnapshotRequest, 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(ProtectSnapshotRequest {
                    name: name__.unwrap_or_default(),
                    request_id: request_id__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.pvs.v1beta1.ProtectSnapshotRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for Snapshot {
    #[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.source_volume.is_empty() {
            len += 1;
        }
        if self.source_size_gib != 0 {
            len += 1;
        }
        if self.state != 0 {
            len += 1;
        }
        if !self.state_reason.is_empty() {
            len += 1;
        }
        if self.protection_state != 0 {
            len += 1;
        }
        if !self.protection_reason.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.pvs.v1beta1.Snapshot", 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.source_volume.is_empty() {
            struct_ser.serialize_field("sourceVolume", &self.source_volume)?;
        }
        if self.source_size_gib != 0 {
            struct_ser.serialize_field("sourceSizeGib", &self.source_size_gib)?;
        }
        if self.state != 0 {
            let v = snapshot::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 self.protection_state != 0 {
            let v = snapshot::ProtectionState::try_from(self.protection_state)
                .map_err(|_| serde::ser::Error::custom(
                    format!("Invalid variant {}", self.protection_state),
                ))?;
            struct_ser.serialize_field("protectionState", &v)?;
        }
        if !self.protection_reason.is_empty() {
            struct_ser.serialize_field("protectionReason", &self.protection_reason)?;
        }
        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 Snapshot {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "name",
            "urn",
            "source_volume",
            "sourceVolume",
            "source_size_gib",
            "sourceSizeGib",
            "state",
            "state_reason",
            "stateReason",
            "protection_state",
            "protectionState",
            "protection_reason",
            "protectionReason",
            "creator",
            "tags",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            Urn,
            SourceVolume,
            SourceSizeGib,
            State,
            StateReason,
            ProtectionState,
            ProtectionReason,
            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),
                            "sourceVolume" | "source_volume" => {
                                Ok(GeneratedField::SourceVolume)
                            }
                            "sourceSizeGib" | "source_size_gib" => {
                                Ok(GeneratedField::SourceSizeGib)
                            }
                            "state" => Ok(GeneratedField::State),
                            "stateReason" | "state_reason" => {
                                Ok(GeneratedField::StateReason)
                            }
                            "protectionState" | "protection_state" => {
                                Ok(GeneratedField::ProtectionState)
                            }
                            "protectionReason" | "protection_reason" => {
                                Ok(GeneratedField::ProtectionReason)
                            }
                            "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 = Snapshot;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.pvs.v1beta1.Snapshot")
            }
            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Snapshot, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                let mut urn__ = None;
                let mut source_volume__ = None;
                let mut source_size_gib__ = None;
                let mut state__ = None;
                let mut state_reason__ = None;
                let mut protection_state__ = None;
                let mut protection_reason__ = 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::SourceVolume => {
                            if source_volume__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("sourceVolume"),
                                );
                            }
                            source_volume__ = Some(map_.next_value()?);
                        }
                        GeneratedField::SourceSizeGib => {
                            if source_size_gib__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("sourceSizeGib"),
                                );
                            }
                            source_size_gib__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::State => {
                            if state__.is_some() {
                                return Err(serde::de::Error::duplicate_field("state"));
                            }
                            state__ = Some(map_.next_value::<snapshot::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::ProtectionState => {
                            if protection_state__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("protectionState"),
                                );
                            }
                            protection_state__ = Some(
                                map_.next_value::<snapshot::ProtectionState>()? as i32,
                            );
                        }
                        GeneratedField::ProtectionReason => {
                            if protection_reason__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("protectionReason"),
                                );
                            }
                            protection_reason__ = 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(Snapshot {
                    name: name__.unwrap_or_default(),
                    urn: urn__.unwrap_or_default(),
                    source_volume: source_volume__.unwrap_or_default(),
                    source_size_gib: source_size_gib__.unwrap_or_default(),
                    state: state__.unwrap_or_default(),
                    state_reason: state_reason__.unwrap_or_default(),
                    protection_state: protection_state__.unwrap_or_default(),
                    protection_reason: protection_reason__.unwrap_or_default(),
                    creator: creator__.unwrap_or_default(),
                    tags: tags__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.pvs.v1beta1.Snapshot",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for snapshot::ProtectionState {
    #[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 => "PROTECTION_STATE_UNSPECIFIED",
            Self::Unprotected => "UNPROTECTED",
            Self::Protecting => "PROTECTING",
            Self::Protected => "PROTECTED",
            Self::Unprotecting => "UNPROTECTING",
            Self::ProtectionFailed => "PROTECTION_FAILED",
        };
        serializer.serialize_str(variant)
    }
}
impl<'de> serde::Deserialize<'de> for snapshot::ProtectionState {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "PROTECTION_STATE_UNSPECIFIED",
            "UNPROTECTED",
            "PROTECTING",
            "PROTECTED",
            "UNPROTECTING",
            "PROTECTION_FAILED",
        ];
        struct GeneratedVisitor;
        impl serde::de::Visitor<'_> for GeneratedVisitor {
            type Value = snapshot::ProtectionState;
            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(snapshot::ProtectionState::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(snapshot::ProtectionState::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 {
                    "PROTECTION_STATE_UNSPECIFIED" => {
                        Ok(snapshot::ProtectionState::Unspecified)
                    }
                    "UNPROTECTED" => Ok(snapshot::ProtectionState::Unprotected),
                    "PROTECTING" => Ok(snapshot::ProtectionState::Protecting),
                    "PROTECTED" => Ok(snapshot::ProtectionState::Protected),
                    "UNPROTECTING" => Ok(snapshot::ProtectionState::Unprotecting),
                    "PROTECTION_FAILED" => {
                        Ok(snapshot::ProtectionState::ProtectionFailed)
                    }
                    _ => Ok(snapshot::ProtectionState::default()),
                }
            }
        }
        deserializer.deserialize_any(GeneratedVisitor)
    }
}
impl serde::Serialize for snapshot::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::Pending => "PENDING",
            Self::Completed => "COMPLETED",
            Self::Deleting => "DELETING",
            Self::Deleted => "DELETED",
            Self::Error => "ERROR",
        };
        serializer.serialize_str(variant)
    }
}
impl<'de> serde::Deserialize<'de> for snapshot::State {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "STATE_UNSPECIFIED",
            "PENDING",
            "COMPLETED",
            "DELETING",
            "DELETED",
            "ERROR",
        ];
        struct GeneratedVisitor;
        impl serde::de::Visitor<'_> for GeneratedVisitor {
            type Value = snapshot::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(snapshot::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(snapshot::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(snapshot::State::Unspecified),
                    "PENDING" => Ok(snapshot::State::Pending),
                    "COMPLETED" => Ok(snapshot::State::Completed),
                    "DELETING" => Ok(snapshot::State::Deleting),
                    "DELETED" => Ok(snapshot::State::Deleted),
                    "ERROR" => Ok(snapshot::State::Error),
                    _ => Ok(snapshot::State::default()),
                }
            }
        }
        deserializer.deserialize_any(GeneratedVisitor)
    }
}
impl serde::Serialize for StorageClass {
    #[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.media != 0 {
            len += 1;
        }
        if self.default_class {
            len += 1;
        }
        if self.available {
            len += 1;
        }
        if self.baseline_iops != 0 {
            len += 1;
        }
        if self.baseline_throughput_mibps != 0 {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.pvs.v1beta1.StorageClass", 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.media != 0 {
            let v = storage_class::Media::try_from(self.media)
                .map_err(|_| serde::ser::Error::custom(
                    format!("Invalid variant {}", self.media),
                ))?;
            struct_ser.serialize_field("media", &v)?;
        }
        if self.default_class {
            struct_ser.serialize_field("defaultClass", &self.default_class)?;
        }
        if self.available {
            struct_ser.serialize_field("available", &self.available)?;
        }
        if self.baseline_iops != 0 {
            struct_ser.serialize_field("baselineIops", &self.baseline_iops)?;
        }
        if self.baseline_throughput_mibps != 0 {
            struct_ser
                .serialize_field(
                    "baselineThroughputMibps",
                    &self.baseline_throughput_mibps,
                )?;
        }
        struct_ser.end()
    }
}
impl<'de> serde::Deserialize<'de> for StorageClass {
    #[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",
            "media",
            "default_class",
            "defaultClass",
            "available",
            "baseline_iops",
            "baselineIops",
            "baseline_throughput_mibps",
            "baselineThroughputMibps",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            DisplayName,
            Media,
            DefaultClass,
            Available,
            BaselineIops,
            BaselineThroughputMibps,
            __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)
                            }
                            "media" => Ok(GeneratedField::Media),
                            "defaultClass" | "default_class" => {
                                Ok(GeneratedField::DefaultClass)
                            }
                            "available" => Ok(GeneratedField::Available),
                            "baselineIops" | "baseline_iops" => {
                                Ok(GeneratedField::BaselineIops)
                            }
                            "baselineThroughputMibps" | "baseline_throughput_mibps" => {
                                Ok(GeneratedField::BaselineThroughputMibps)
                            }
                            _ => Ok(GeneratedField::__SkipField__),
                        }
                    }
                }
                deserializer.deserialize_identifier(GeneratedVisitor)
            }
        }
        struct GeneratedVisitor;
        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
            type Value = StorageClass;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.pvs.v1beta1.StorageClass")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<StorageClass, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                let mut display_name__ = None;
                let mut media__ = None;
                let mut default_class__ = None;
                let mut available__ = None;
                let mut baseline_iops__ = None;
                let mut baseline_throughput_mibps__ = 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::Media => {
                            if media__.is_some() {
                                return Err(serde::de::Error::duplicate_field("media"));
                            }
                            media__ = Some(
                                map_.next_value::<storage_class::Media>()? as i32,
                            );
                        }
                        GeneratedField::DefaultClass => {
                            if default_class__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("defaultClass"),
                                );
                            }
                            default_class__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Available => {
                            if available__.is_some() {
                                return Err(serde::de::Error::duplicate_field("available"));
                            }
                            available__ = Some(map_.next_value()?);
                        }
                        GeneratedField::BaselineIops => {
                            if baseline_iops__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("baselineIops"),
                                );
                            }
                            baseline_iops__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::BaselineThroughputMibps => {
                            if baseline_throughput_mibps__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("baselineThroughputMibps"),
                                );
                            }
                            baseline_throughput_mibps__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::__SkipField__ => {
                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                Ok(StorageClass {
                    name: name__.unwrap_or_default(),
                    display_name: display_name__.unwrap_or_default(),
                    media: media__.unwrap_or_default(),
                    default_class: default_class__.unwrap_or_default(),
                    available: available__.unwrap_or_default(),
                    baseline_iops: baseline_iops__.unwrap_or_default(),
                    baseline_throughput_mibps: baseline_throughput_mibps__
                        .unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.pvs.v1beta1.StorageClass",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for storage_class::Media {
    #[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 => "MEDIA_UNSPECIFIED",
            Self::Ssd => "SSD",
            Self::Hdd => "HDD",
        };
        serializer.serialize_str(variant)
    }
}
impl<'de> serde::Deserialize<'de> for storage_class::Media {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["MEDIA_UNSPECIFIED", "SSD", "HDD"];
        struct GeneratedVisitor;
        impl serde::de::Visitor<'_> for GeneratedVisitor {
            type Value = storage_class::Media;
            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(storage_class::Media::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(storage_class::Media::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 {
                    "MEDIA_UNSPECIFIED" => Ok(storage_class::Media::Unspecified),
                    "SSD" => Ok(storage_class::Media::Ssd),
                    "HDD" => Ok(storage_class::Media::Hdd),
                    _ => Ok(storage_class::Media::default()),
                }
            }
        }
        deserializer.deserialize_any(GeneratedVisitor)
    }
}
impl serde::Serialize for UnprotectSnapshotRequest {
    #[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.pvs.v1beta1.UnprotectSnapshotRequest", 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 UnprotectSnapshotRequest {
    #[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 = UnprotectSnapshotRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.pvs.v1beta1.UnprotectSnapshotRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<UnprotectSnapshotRequest, 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(UnprotectSnapshotRequest {
                    name: name__.unwrap_or_default(),
                    request_id: request_id__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.pvs.v1beta1.UnprotectSnapshotRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for UpdateSnapshotRequest {
    #[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.snapshot.is_some() {
            len += 1;
        }
        if self.update_mask.is_some() {
            len += 1;
        }
        let mut struct_ser = serializer
            .serialize_struct("origincloud.pvs.v1beta1.UpdateSnapshotRequest", len)?;
        if let Some(v) = self.snapshot.as_ref() {
            struct_ser.serialize_field("snapshot", 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 UpdateSnapshotRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &["snapshot", "update_mask", "updateMask"];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Snapshot,
            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 {
                            "snapshot" => Ok(GeneratedField::Snapshot),
                            "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 = UpdateSnapshotRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter
                    .write_str("struct origincloud.pvs.v1beta1.UpdateSnapshotRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<UpdateSnapshotRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut snapshot__ = None;
                let mut update_mask__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Snapshot => {
                            if snapshot__.is_some() {
                                return Err(serde::de::Error::duplicate_field("snapshot"));
                            }
                            snapshot__ = 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(UpdateSnapshotRequest {
                    snapshot: snapshot__,
                    update_mask: update_mask__,
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.pvs.v1beta1.UpdateSnapshotRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for UpdateVolumeRequest {
    #[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.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.pvs.v1beta1.UpdateVolumeRequest", len)?;
        if let Some(v) = self.volume.as_ref() {
            struct_ser.serialize_field("volume", 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 UpdateVolumeRequest {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "volume",
            "update_mask",
            "updateMask",
            "request_id",
            "requestId",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Volume,
            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 {
                            "volume" => Ok(GeneratedField::Volume),
                            "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 = UpdateVolumeRequest;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.pvs.v1beta1.UpdateVolumeRequest")
            }
            fn visit_map<V>(
                self,
                mut map_: V,
            ) -> std::result::Result<UpdateVolumeRequest, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut volume__ = None;
                let mut update_mask__ = None;
                let mut request_id__ = None;
                while let Some(k) = map_.next_key()? {
                    match k {
                        GeneratedField::Volume => {
                            if volume__.is_some() {
                                return Err(serde::de::Error::duplicate_field("volume"));
                            }
                            volume__ = 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(UpdateVolumeRequest {
                    volume: volume__,
                    update_mask: update_mask__,
                    request_id: request_id__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.pvs.v1beta1.UpdateVolumeRequest",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for Volume {
    #[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.size_gib != 0 {
            len += 1;
        }
        if !self.storage_class.is_empty() {
            len += 1;
        }
        if !self.source_snapshot.is_empty() {
            len += 1;
        }
        if self.state != 0 {
            len += 1;
        }
        if !self.state_reason.is_empty() {
            len += 1;
        }
        if !self.attachment.is_empty() {
            len += 1;
        }
        if self.resize_state != 0 {
            len += 1;
        }
        if !self.resize_reason.is_empty() {
            len += 1;
        }
        if self.pending_size_gib != 0 {
            len += 1;
        }
        if !self.retention_note.is_empty() {
            len += 1;
        }
        if self.iops != 0 {
            len += 1;
        }
        if self.throughput_mibps != 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.pvs.v1beta1.Volume", 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.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.source_snapshot.is_empty() {
            struct_ser.serialize_field("sourceSnapshot", &self.source_snapshot)?;
        }
        if self.state != 0 {
            let v = volume::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 !self.attachment.is_empty() {
            struct_ser.serialize_field("attachment", &self.attachment)?;
        }
        if self.resize_state != 0 {
            let v = volume::ResizeState::try_from(self.resize_state)
                .map_err(|_| serde::ser::Error::custom(
                    format!("Invalid variant {}", self.resize_state),
                ))?;
            struct_ser.serialize_field("resizeState", &v)?;
        }
        if !self.resize_reason.is_empty() {
            struct_ser.serialize_field("resizeReason", &self.resize_reason)?;
        }
        if self.pending_size_gib != 0 {
            struct_ser.serialize_field("pendingSizeGib", &self.pending_size_gib)?;
        }
        if !self.retention_note.is_empty() {
            struct_ser.serialize_field("retentionNote", &self.retention_note)?;
        }
        if self.iops != 0 {
            struct_ser.serialize_field("iops", &self.iops)?;
        }
        if self.throughput_mibps != 0 {
            struct_ser.serialize_field("throughputMibps", &self.throughput_mibps)?;
        }
        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 Volume {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "name",
            "urn",
            "size_gib",
            "sizeGib",
            "storage_class",
            "storageClass",
            "source_snapshot",
            "sourceSnapshot",
            "state",
            "state_reason",
            "stateReason",
            "attachment",
            "resize_state",
            "resizeState",
            "resize_reason",
            "resizeReason",
            "pending_size_gib",
            "pendingSizeGib",
            "retention_note",
            "retentionNote",
            "iops",
            "throughput_mibps",
            "throughputMibps",
            "creator",
            "tags",
        ];
        #[allow(clippy::enum_variant_names)]
        enum GeneratedField {
            Name,
            Urn,
            SizeGib,
            StorageClass,
            SourceSnapshot,
            State,
            StateReason,
            Attachment,
            ResizeState,
            ResizeReason,
            PendingSizeGib,
            RetentionNote,
            Iops,
            ThroughputMibps,
            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),
                            "sizeGib" | "size_gib" => Ok(GeneratedField::SizeGib),
                            "storageClass" | "storage_class" => {
                                Ok(GeneratedField::StorageClass)
                            }
                            "sourceSnapshot" | "source_snapshot" => {
                                Ok(GeneratedField::SourceSnapshot)
                            }
                            "state" => Ok(GeneratedField::State),
                            "stateReason" | "state_reason" => {
                                Ok(GeneratedField::StateReason)
                            }
                            "attachment" => Ok(GeneratedField::Attachment),
                            "resizeState" | "resize_state" => {
                                Ok(GeneratedField::ResizeState)
                            }
                            "resizeReason" | "resize_reason" => {
                                Ok(GeneratedField::ResizeReason)
                            }
                            "pendingSizeGib" | "pending_size_gib" => {
                                Ok(GeneratedField::PendingSizeGib)
                            }
                            "retentionNote" | "retention_note" => {
                                Ok(GeneratedField::RetentionNote)
                            }
                            "iops" => Ok(GeneratedField::Iops),
                            "throughputMibps" | "throughput_mibps" => {
                                Ok(GeneratedField::ThroughputMibps)
                            }
                            "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 = Volume;
            fn expecting(
                &self,
                formatter: &mut std::fmt::Formatter<'_>,
            ) -> std::fmt::Result {
                formatter.write_str("struct origincloud.pvs.v1beta1.Volume")
            }
            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Volume, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut name__ = None;
                let mut urn__ = None;
                let mut size_gib__ = None;
                let mut storage_class__ = None;
                let mut source_snapshot__ = None;
                let mut state__ = None;
                let mut state_reason__ = None;
                let mut attachment__ = None;
                let mut resize_state__ = None;
                let mut resize_reason__ = None;
                let mut pending_size_gib__ = None;
                let mut retention_note__ = None;
                let mut iops__ = None;
                let mut throughput_mibps__ = 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::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::SourceSnapshot => {
                            if source_snapshot__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("sourceSnapshot"),
                                );
                            }
                            source_snapshot__ = Some(map_.next_value()?);
                        }
                        GeneratedField::State => {
                            if state__.is_some() {
                                return Err(serde::de::Error::duplicate_field("state"));
                            }
                            state__ = Some(map_.next_value::<volume::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::Attachment => {
                            if attachment__.is_some() {
                                return Err(serde::de::Error::duplicate_field("attachment"));
                            }
                            attachment__ = Some(map_.next_value()?);
                        }
                        GeneratedField::ResizeState => {
                            if resize_state__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("resizeState"),
                                );
                            }
                            resize_state__ = Some(
                                map_.next_value::<volume::ResizeState>()? as i32,
                            );
                        }
                        GeneratedField::ResizeReason => {
                            if resize_reason__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("resizeReason"),
                                );
                            }
                            resize_reason__ = Some(map_.next_value()?);
                        }
                        GeneratedField::PendingSizeGib => {
                            if pending_size_gib__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("pendingSizeGib"),
                                );
                            }
                            pending_size_gib__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::RetentionNote => {
                            if retention_note__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("retentionNote"),
                                );
                            }
                            retention_note__ = Some(map_.next_value()?);
                        }
                        GeneratedField::Iops => {
                            if iops__.is_some() {
                                return Err(serde::de::Error::duplicate_field("iops"));
                            }
                            iops__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        GeneratedField::ThroughputMibps => {
                            if throughput_mibps__.is_some() {
                                return Err(
                                    serde::de::Error::duplicate_field("throughputMibps"),
                                );
                            }
                            throughput_mibps__ = Some(
                                map_
                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
                                    .0,
                            );
                        }
                        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(Volume {
                    name: name__.unwrap_or_default(),
                    urn: urn__.unwrap_or_default(),
                    size_gib: size_gib__.unwrap_or_default(),
                    storage_class: storage_class__.unwrap_or_default(),
                    source_snapshot: source_snapshot__.unwrap_or_default(),
                    state: state__.unwrap_or_default(),
                    state_reason: state_reason__.unwrap_or_default(),
                    attachment: attachment__.unwrap_or_default(),
                    resize_state: resize_state__.unwrap_or_default(),
                    resize_reason: resize_reason__.unwrap_or_default(),
                    pending_size_gib: pending_size_gib__.unwrap_or_default(),
                    retention_note: retention_note__.unwrap_or_default(),
                    iops: iops__.unwrap_or_default(),
                    throughput_mibps: throughput_mibps__.unwrap_or_default(),
                    creator: creator__.unwrap_or_default(),
                    tags: tags__.unwrap_or_default(),
                })
            }
        }
        deserializer
            .deserialize_struct(
                "origincloud.pvs.v1beta1.Volume",
                FIELDS,
                GeneratedVisitor,
            )
    }
}
impl serde::Serialize for volume::ResizeState {
    #[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 => "RESIZE_STATE_UNSPECIFIED",
            Self::ResizeCompleted => "RESIZE_COMPLETED",
            Self::Resizing => "RESIZING",
            Self::ResizeFailed => "RESIZE_FAILED",
        };
        serializer.serialize_str(variant)
    }
}
impl<'de> serde::Deserialize<'de> for volume::ResizeState {
    #[allow(deprecated)]
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        const FIELDS: &[&str] = &[
            "RESIZE_STATE_UNSPECIFIED",
            "RESIZE_COMPLETED",
            "RESIZING",
            "RESIZE_FAILED",
        ];
        struct GeneratedVisitor;
        impl serde::de::Visitor<'_> for GeneratedVisitor {
            type Value = volume::ResizeState;
            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::ResizeState::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::ResizeState::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 {
                    "RESIZE_STATE_UNSPECIFIED" => Ok(volume::ResizeState::Unspecified),
                    "RESIZE_COMPLETED" => Ok(volume::ResizeState::ResizeCompleted),
                    "RESIZING" => Ok(volume::ResizeState::Resizing),
                    "RESIZE_FAILED" => Ok(volume::ResizeState::ResizeFailed),
                    _ => Ok(volume::ResizeState::default()),
                }
            }
        }
        deserializer.deserialize_any(GeneratedVisitor)
    }
}
impl serde::Serialize for volume::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::Available => "AVAILABLE",
            Self::InUse => "IN_USE",
            Self::Deleting => "DELETING",
            Self::Deleted => "DELETED",
            Self::Error => "ERROR",
        };
        serializer.serialize_str(variant)
    }
}
impl<'de> serde::Deserialize<'de> for volume::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",
            "AVAILABLE",
            "IN_USE",
            "DELETING",
            "DELETED",
            "ERROR",
        ];
        struct GeneratedVisitor;
        impl serde::de::Visitor<'_> for GeneratedVisitor {
            type Value = volume::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::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::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::State::Unspecified),
                    "CREATING" => Ok(volume::State::Creating),
                    "AVAILABLE" => Ok(volume::State::Available),
                    "IN_USE" => Ok(volume::State::InUse),
                    "DELETING" => Ok(volume::State::Deleting),
                    "DELETED" => Ok(volume::State::Deleted),
                    "ERROR" => Ok(volume::State::Error),
                    _ => Ok(volume::State::default()),
                }
            }
        }
        deserializer.deserialize_any(GeneratedVisitor)
    }
}
/// Calls `SnapshotService`.
///
/// Snapshots: point-in-time copies of a volume, in the volume's zone. A
/// protected, completed snapshot is the source of new volumes and images.
#[derive(Clone, Debug)]
pub struct SnapshotClient {
    service: ::origincloud_core::Service,
}
impl SnapshotClient {
    /// Returns a client of `SnapshotService` that sends its calls through `client`.
    pub fn new(client: &::origincloud_core::Client) -> Self {
        Self {
            service: client.service("pvs", 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 snapshot.
    pub async fn get_snapshot(
        &self,
        request: GetSnapshotRequest,
    ) -> ::core::result::Result<Snapshot, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "name",
            &request.name,
            "projects/*/zones/*/snapshots/*",
        )?;
        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 snapshots in a zone, oldest first. Deleted snapshots aren't
    /// listed. For every zone's snapshots, list the zones whose `services` name
    /// `pvs` with the location service (`location.origincloudapis.eu`), then
    /// each zone's snapshots.
    pub async fn list_snapshots(
        &self,
        request: ListSnapshotsRequest,
    ) -> ::core::result::Result<ListSnapshotsResponse, ::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}/snapshots"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Returns everything [`list_snapshots`](Self::list_snapshots) 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_snapshots(
        &self,
        request: ListSnapshotsRequest,
    ) -> ::origincloud_core::Pages<Snapshot> {
        let client = self.clone();
        ::origincloud_core::Pages::new(
            request,
            move |request: ListSnapshotsRequest| {
                let client = client.clone();
                async move {
                    let page = client.list_snapshots(request).await?;
                    Ok((page.snapshots, page.next_page_token))
                }
            },
            |request: &mut ListSnapshotsRequest, token: ::std::string::String| {
                request.page_token = token;
            },
        )
    }
    /// Takes a snapshot of a volume. The operation is done once the copy is
    /// `snapshot::State::Completed`, or failed once it is `snapshot::State::Error`.
    ///
    /// It answers with an operation to wait on: [`Operation::wait`](origincloud_core::Operation::wait) returns the [`Snapshot`] once the change is done.
    pub async fn create_snapshot(
        &self,
        mut request: CreateSnapshotRequest,
    ) -> ::core::result::Result<
        ::origincloud_core::Operation<Snapshot>,
        ::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.snapshot.as_ref().unwrap_or(&::core::default::Default::default()),
        )?;
        let query = ::origincloud_core::query(&request, &["parent", "snapshot"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::POST,
                format!("/v1beta1/{p0}/snapshots"),
            )
            .with_body(body)
            .with_query(query)
            .idempotent();
        let operation = self.service.call(call).await?;
        Ok(
            ::origincloud_core::Operation::new(
                self.service.clone(),
                operation,
                "origincloud.pvs.v1beta1.Snapshot",
            ),
        )
    }
    /// Changes a snapshot's tags.
    pub async fn update_snapshot(
        &self,
        request: UpdateSnapshotRequest,
    ) -> ::core::result::Result<Snapshot, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "snapshot.name",
            request.snapshot.as_ref().map_or("", |m| m.name.as_str()),
            "projects/*/zones/*/snapshots/*",
        )?;
        let body = ::origincloud_core::json_body(
            request.snapshot.as_ref().unwrap_or(&::core::default::Default::default()),
        )?;
        let query = ::origincloud_core::query(&request, &["snapshot.name", "snapshot"])?;
        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 snapshot. It must be `snapshot::State::Completed` or `snapshot::State::Error`, and unprotected.
    /// The operation is done once the snapshot is `snapshot::State::Deleted`.
    ///
    /// 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_snapshot(
        &self,
        mut request: DeleteSnapshotRequest,
    ) -> ::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/*/snapshots/*",
        )?;
        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",
            ),
        )
    }
    /// Protects a snapshot, so it can be the source of volumes and images and
    /// can't be deleted. The operation is done once it is `snapshot::ProtectionState::Protected`.
    ///
    /// It answers with an operation to wait on: [`Operation::wait`](origincloud_core::Operation::wait) returns the [`Snapshot`] once the change is done.
    pub async fn protect_snapshot(
        &self,
        mut request: ProtectSnapshotRequest,
    ) -> ::core::result::Result<
        ::origincloud_core::Operation<Snapshot>,
        ::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/*/snapshots/*",
        )?;
        let body = ::origincloud_core::json_body(&request)?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::POST,
                format!("/v1beta1/{p0}:protect"),
            )
            .with_body(body)
            .idempotent();
        let operation = self.service.call(call).await?;
        Ok(
            ::origincloud_core::Operation::new(
                self.service.clone(),
                operation,
                "origincloud.pvs.v1beta1.Snapshot",
            ),
        )
    }
    /// Unprotects a snapshot, so it can be deleted. Refused with
    /// `FAILED_PRECONDITION` while an image is built from it or a volume not
    /// `snapshot::State::Deleted` was created from it; delete those first. The operation is
    /// done once it is `snapshot::ProtectionState::Unprotected`.
    ///
    /// It answers with an operation to wait on: [`Operation::wait`](origincloud_core::Operation::wait) returns the [`Snapshot`] once the change is done.
    pub async fn unprotect_snapshot(
        &self,
        mut request: UnprotectSnapshotRequest,
    ) -> ::core::result::Result<
        ::origincloud_core::Operation<Snapshot>,
        ::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/*/snapshots/*",
        )?;
        let body = ::origincloud_core::json_body(&request)?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::POST,
                format!("/v1beta1/{p0}:unprotect"),
            )
            .with_body(body)
            .idempotent();
        let operation = self.service.call(call).await?;
        Ok(
            ::origincloud_core::Operation::new(
                self.service.clone(),
                operation,
                "origincloud.pvs.v1beta1.Snapshot",
            ),
        )
    }
}
/// Calls `StorageClassService`.
///
/// The catalog of storage classes: every tier the platform publishes, each
/// saying whether it can be selected right now. Not scoped to an
/// organisation or a project; no permission is needed.
#[derive(Clone, Debug)]
pub struct StorageClassClient {
    service: ::origincloud_core::Service,
}
impl StorageClassClient {
    /// Returns a client of `StorageClassService` that sends its calls through `client`.
    pub fn new(client: &::origincloud_core::Client) -> Self {
        Self {
            service: client.service("pvs", 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 storage class.
    pub async fn get_storage_class(
        &self,
        request: GetStorageClassRequest,
    ) -> ::core::result::Result<StorageClass, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "name",
            &request.name,
            "storageClasses/*",
        )?;
        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 storage class, including those not yet on sale: check
    /// `available` before selecting one.
    pub async fn list_storage_classes(
        &self,
        request: ListStorageClassesRequest,
    ) -> ::core::result::Result<ListStorageClassesResponse, ::origincloud_core::Error> {
        let query = ::origincloud_core::query(&request, &[])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::GET,
                ::std::string::String::from("/v1beta1/storageClasses"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
}
/// Calls `VolumeService`.
///
/// Block storage volumes: durable disks in one zone that an instance attaches
/// to read and write.
#[derive(Clone, Debug)]
pub struct VolumeClient {
    service: ::origincloud_core::Service,
}
impl VolumeClient {
    /// Returns a client of `VolumeService` that sends its calls through `client`.
    pub fn new(client: &::origincloud_core::Client) -> Self {
        Self {
            service: client.service("pvs", 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.
    pub async fn get_volume(
        &self,
        request: GetVolumeRequest,
    ) -> ::core::result::Result<Volume, ::origincloud_core::Error> {
        let p0 = ::origincloud_core::path_value(
            "name",
            &request.name,
            "projects/*/zones/*/volumes/*",
        )?;
        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 volumes in a zone, oldest first. Deleted volumes aren't
    /// listed. For every zone's volumes, list the zones whose `services` name
    /// `pvs` with the location service (`location.origincloudapis.eu`), then
    /// each zone's volumes.
    pub async fn list_volumes(
        &self,
        request: ListVolumesRequest,
    ) -> ::core::result::Result<ListVolumesResponse, ::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}/volumes"),
            )
            .with_query(query)
            .idempotent();
        self.service.call(call).await
    }
    /// Returns everything [`list_volumes`](Self::list_volumes) 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_volumes(
        &self,
        request: ListVolumesRequest,
    ) -> ::origincloud_core::Pages<Volume> {
        let client = self.clone();
        ::origincloud_core::Pages::new(
            request,
            move |request: ListVolumesRequest| {
                let client = client.clone();
                async move {
                    let page = client.list_volumes(request).await?;
                    Ok((page.volumes, page.next_page_token))
                }
            },
            |request: &mut ListVolumesRequest, token: ::std::string::String| {
                request.page_token = token;
            },
        )
    }
    /// Creates a volume, empty or as a copy of a snapshot. The operation is
    /// done once the volume is `volume::State::Available`, or failed once it is `volume::State::Error`.
    ///
    /// It answers with an operation to wait on: [`Operation::wait`](origincloud_core::Operation::wait) returns the [`Volume`] once the change is done.
    pub async fn create_volume(
        &self,
        mut request: CreateVolumeRequest,
    ) -> ::core::result::Result<
        ::origincloud_core::Operation<Volume>,
        ::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.volume.as_ref().unwrap_or(&::core::default::Default::default()),
        )?;
        let query = ::origincloud_core::query(&request, &["parent", "volume"])?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::POST,
                format!("/v1beta1/{p0}/volumes"),
            )
            .with_body(body)
            .with_query(query)
            .idempotent();
        let operation = self.service.call(call).await?;
        Ok(
            ::origincloud_core::Operation::new(
                self.service.clone(),
                operation,
                "origincloud.pvs.v1beta1.Volume",
            ),
        )
    }
    /// Creates a volume whose initial content is a disk image the platform
    /// downloads. The operation is done once the volume is `volume::State::Available`.
    ///
    /// It answers with an operation to wait on: [`Operation::wait`](origincloud_core::Operation::wait) returns the [`Volume`] once the change is done.
    pub async fn import_volume(
        &self,
        mut request: ImportVolumeRequest,
    ) -> ::core::result::Result<
        ::origincloud_core::Operation<Volume>,
        ::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)?;
        let call = ::origincloud_core::Request::new(
                ::origincloud_core::Method::POST,
                format!("/v1beta1/{p0}/volumes:import"),
            )
            .with_body(body)
            .idempotent();
        let operation = self.service.call(call).await?;
        Ok(
            ::origincloud_core::Operation::new(
                self.service.clone(),
                operation,
                "origincloud.pvs.v1beta1.Volume",
            ),
        )
    }
    /// Changes a volume's size or tags. A larger `size_gib` grows the volume,
    /// attached or not; it never shrinks, and the size it already has changes
    /// nothing. The operation is done once the volume reports the new size.
    ///
    /// It answers with an operation to wait on: [`Operation::wait`](origincloud_core::Operation::wait) returns the [`Volume`] once the change is done.
    pub async fn update_volume(
        &self,
        mut request: UpdateVolumeRequest,
    ) -> ::core::result::Result<
        ::origincloud_core::Operation<Volume>,
        ::origincloud_core::Error,
    > {
        if request.request_id.is_empty() {
            request.request_id = ::origincloud_core::new_request_id();
        }
        let p0 = ::origincloud_core::path_value(
            "volume.name",
            request.volume.as_ref().map_or("", |m| m.name.as_str()),
            "projects/*/zones/*/volumes/*",
        )?;
        let body = ::origincloud_core::json_body(
            request.volume.as_ref().unwrap_or(&::core::default::Default::default()),
        )?;
        let query = ::origincloud_core::query(&request, &["volume.name", "volume"])?;
        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.pvs.v1beta1.Volume",
            ),
        )
    }
    /// Deletes a volume. It must not be attached, and none of its snapshots
    /// may be left. The operation is done once the volume is `volume::State::Deleted`.
    ///
    /// 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(
        &self,
        mut request: DeleteVolumeRequest,
    ) -> ::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/*/volumes/*",
        )?;
        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",
            ),
        )
    }
}