yandex-cloud 2025.4.14

#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Policy {
    /// Policy ID.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Policy name.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "3")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    #[prost(message, optional, tag = "4")]
    pub updated_at: ::core::option::Option<::prost_types::Timestamp>,
    /// If this field is true, it means that the policy is enabled.
    #[prost(bool, tag = "5")]
    pub enabled: bool,
    /// Set of policy settings
    #[prost(message, optional, tag = "6")]
    pub settings: ::core::option::Option<PolicySettings>,
    /// ID of the folder that the policy belongs to.
    #[prost(string, tag = "7")]
    pub folder_id: ::prost::alloc::string::String,
}
/// Set of policy settings
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PolicySettings {
    /// Archive compression level.
    #[prost(enumeration = "policy_settings::Compression", tag = "1")]
    pub compression: i32,
    /// Format of the Acronis backup archive.
    #[prost(enumeration = "Format", tag = "2")]
    pub format: i32,
    /// If true, snapshots of multiple volumes will be taken simultaneously.
    #[prost(bool, tag = "3")]
    pub multi_volume_snapshotting_enabled: bool,
    /// If true, the file security settings will be preserved.
    /// Deprecated.
    #[deprecated]
    #[prost(bool, tag = "4")]
    pub preserve_file_security_settings: bool,
    /// Configuration of retries on recoverable errors during the backup operations like reconnection to destination. No attempts to fix recoverable errors will be made if retry configuration is not set.
    #[prost(message, optional, tag = "5")]
    pub reattempts: ::core::option::Option<policy_settings::RetriesConfiguration>,
    /// If true, a user interaction will be avoided when possible. Equals to false if value is not specified.
    #[prost(bool, tag = "6")]
    pub silent_mode_enabled: bool,
    /// Determines the size to split backups on. Splitting is not performed if value is not specified.
    #[prost(message, optional, tag = "7")]
    pub splitting: ::core::option::Option<policy_settings::Splitting>,
    /// Configuration of retries on errors during the creation of the virtual machine snapshot. No attempts to fix recoverable errors will be made if retry configuration is not set.
    #[prost(message, optional, tag = "8")]
    pub vm_snapshot_reattempts: ::core::option::Option<
        policy_settings::RetriesConfiguration,
    >,
    /// Settings for the Volume Shadow Copy Service (VSS) provider. If not set, no VSS provider is used.
    #[prost(message, optional, tag = "9")]
    pub vss: ::core::option::Option<policy_settings::VolumeShadowCopyServiceSettings>,
    /// The archive properties.
    #[prost(message, optional, tag = "10")]
    pub archive: ::core::option::Option<policy_settings::ArchiveProperties>,
    /// Time windows for performance limitations of backup and storage maintenance operations.
    #[prost(message, optional, tag = "11")]
    pub performance_window: ::core::option::Option<policy_settings::PerformanceWindow>,
    /// Configuration of backup retention rules.
    #[prost(message, optional, tag = "12")]
    pub retention: ::core::option::Option<policy_settings::Retention>,
    /// Configuration of the backup schedule.
    #[prost(message, optional, tag = "15")]
    pub scheduling: ::core::option::Option<policy_settings::Scheduling>,
    /// A configuration of Changed Block Tracking (CBT).
    #[prost(enumeration = "policy_settings::ChangedBlockTracking", tag = "16")]
    pub cbt: i32,
    /// If true, determines whether a file has changed by the file size and timestamp. Otherwise, the entire file contents are compared to those stored in the backup.
    #[prost(bool, tag = "17")]
    pub fast_backup_enabled: bool,
    /// If true, a quiesced snapshot of the virtual machine will be taken.
    /// Deprecated.
    #[deprecated]
    #[prost(bool, tag = "18")]
    pub quiesce_snapshotting_enabled: bool,
    /// File filters to specify masks of files to backup or to exclude of backuping
    #[prost(message, optional, tag = "19")]
    pub file_filters: ::core::option::Option<policy_settings::FileFilters>,
    /// A sector-by-sector backup of a disk or volume creates a backup copy of all sectors of the disk or volume,
    /// including those that do not contain data.
    /// Therefore, the size of such a backup copy will be equal to the size of the original disk or volume.
    /// This method can be used to back up a disk or volume with an unsupported file system.
    #[prost(bool, tag = "20")]
    pub sector_by_sector: bool,
    /// Validation is a time-consuming process, even with incremental or differential backups of small amounts of data.
    /// This is because not only the data physically contained in the backup copy is verified,
    /// but all data restored when it is selected.
    /// This option requires access to previously created backup copies.
    #[prost(bool, tag = "21")]
    pub validation_enabled: bool,
    /// LVM will be used to create the volume snapshot.
    /// If LVM fails to create a snapshot (for example, because there is not enough free space),
    /// the software will create the snapshot itself.
    #[prost(bool, tag = "22")]
    pub lvm_snapshotting_enabled: bool,
}
/// Nested message and enum types in `PolicySettings`.
pub mod policy_settings {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Interval {
        /// A type of the interval.
        #[prost(enumeration = "interval::Type", tag = "1")]
        pub r#type: i32,
        /// The amount of value specified in `Interval.Type`.
        #[prost(int64, tag = "2")]
        pub count: i64,
    }
    /// Nested message and enum types in `Interval`.
    pub mod interval {
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum Type {
            Unspecified = 0,
            Seconds = 1,
            Minutes = 2,
            Hours = 3,
            Days = 4,
            Weeks = 5,
            Months = 6,
        }
        impl Type {
            /// String value of the enum field names used in the ProtoBuf definition.
            ///
            /// The values are not transformed in any way and thus are considered stable
            /// (if the ProtoBuf definition does not change) and safe for programmatic use.
            pub fn as_str_name(&self) -> &'static str {
                match self {
                    Type::Unspecified => "TYPE_UNSPECIFIED",
                    Type::Seconds => "SECONDS",
                    Type::Minutes => "MINUTES",
                    Type::Hours => "HOURS",
                    Type::Days => "DAYS",
                    Type::Weeks => "WEEKS",
                    Type::Months => "MONTHS",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                    "SECONDS" => Some(Self::Seconds),
                    "MINUTES" => Some(Self::Minutes),
                    "HOURS" => Some(Self::Hours),
                    "DAYS" => Some(Self::Days),
                    "WEEKS" => Some(Self::Weeks),
                    "MONTHS" => Some(Self::Months),
                    _ => None,
                }
            }
        }
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RetriesConfiguration {
        /// If true, enables retry on errors.
        #[prost(bool, tag = "1")]
        pub enabled: bool,
        /// An interval between retry attempts.
        #[prost(message, optional, tag = "2")]
        pub interval: ::core::option::Option<Interval>,
        /// Max number of retry attempts. Operation will be considered as failed
        /// when max number of retry attempts is reached.
        #[prost(int64, tag = "3")]
        pub max_attempts: i64,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Splitting {
        /// The size of split backup file in bytes.
        #[prost(int64, tag = "1")]
        pub size: i64,
    }
    /// Settings for Volume Shadow Copy Services which allows to notify
    /// VSS-aware applications that backup is about to start. This will
    /// ensure the consistent state of all data used by the applications.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct VolumeShadowCopyServiceSettings {
        /// If true, the VSS will be enabled.
        #[prost(bool, tag = "1")]
        pub enabled: bool,
        /// A type of VSS provider to use in backup.
        #[prost(
            enumeration = "volume_shadow_copy_service_settings::VssProvider",
            tag = "2"
        )]
        pub provider: i32,
    }
    /// Nested message and enum types in `VolumeShadowCopyServiceSettings`.
    pub mod volume_shadow_copy_service_settings {
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum VssProvider {
            Unspecified = 0,
            Native = 1,
            TargetSystemDefined = 2,
        }
        impl VssProvider {
            /// 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 {
                    VssProvider::Unspecified => "VSS_PROVIDER_UNSPECIFIED",
                    VssProvider::Native => "NATIVE",
                    VssProvider::TargetSystemDefined => "TARGET_SYSTEM_DEFINED",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "VSS_PROVIDER_UNSPECIFIED" => Some(Self::Unspecified),
                    "NATIVE" => Some(Self::Native),
                    "TARGET_SYSTEM_DEFINED" => Some(Self::TargetSystemDefined),
                    _ => None,
                }
            }
        }
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ArchiveProperties {
        /// The name of the generated archive. The name may use the following variables: `[Machine Name]`, `[Plan ID]`, `[Plan Name]`, `[Unique ID]`, `[Virtualization Server Type]`.
        /// Default value: `[Machine Name]-[Plan ID]-[Unique ID]A`.
        #[prost(string, tag = "1")]
        pub name: ::prost::alloc::string::String,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct PerformanceWindow {
        /// If true, the time windows will be enabled.
        #[prost(bool, tag = "1")]
        pub enabled: bool,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct TimeOfDay {
        /// Hours.
        #[prost(int64, tag = "1")]
        pub hour: i64,
        /// Minutes.
        #[prost(int64, tag = "2")]
        pub minute: i64,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Retention {
        /// A list of retention rules.
        #[prost(message, repeated, tag = "1")]
        pub rules: ::prost::alloc::vec::Vec<retention::RetentionRule>,
        /// If true, retention rules will be applied before backup is finished.
        #[prost(bool, tag = "3")]
        pub before_backup: bool,
    }
    /// Nested message and enum types in `Retention`.
    pub mod retention {
        #[allow(clippy::derive_partial_eq_without_eq)]
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct RetentionRule {
            /// A list of backup sets where rules are effective.
            #[prost(enumeration = "super::RepeatePeriod", repeated, tag = "1")]
            pub backup_set: ::prost::alloc::vec::Vec<i32>,
            #[prost(oneof = "retention_rule::Condition", tags = "2, 3")]
            pub condition: ::core::option::Option<retention_rule::Condition>,
        }
        /// Nested message and enum types in `RetentionRule`.
        pub mod retention_rule {
            #[allow(clippy::derive_partial_eq_without_eq)]
            #[derive(Clone, PartialEq, ::prost::Oneof)]
            pub enum Condition {
                #[prost(message, tag = "2")]
                MaxAge(super::super::Interval),
                #[prost(int64, tag = "3")]
                MaxCount(i64),
            }
        }
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Scheduling {
        /// A list of schedules with backup sets that compose the whole scheme.
        #[prost(message, repeated, tag = "1")]
        pub backup_sets: ::prost::alloc::vec::Vec<scheduling::BackupSet>,
        /// If true, the backup schedule will be enabled.
        #[prost(bool, tag = "2")]
        pub enabled: bool,
        /// Max number of backup processes allowed to run in parallel. Unlimited if not set.
        #[prost(int64, tag = "3")]
        pub max_parallel_backups: i64,
        /// Configuration of the random delay between the execution of parallel tasks.
        #[prost(message, optional, tag = "4")]
        pub rand_max_delay: ::core::option::Option<Interval>,
        /// A backup scheme. Available values: `simple`, `always_full`, `always_incremental`, `weekly_incremental`, `weekly_full_daily_incremental`, `custom`, `cdp`.
        #[prost(enumeration = "scheduling::Scheme", tag = "5")]
        pub scheme: i32,
        /// A day of week to start weekly backups.
        #[prost(enumeration = "Day", tag = "6")]
        pub weekly_backup_day: i32,
        /// Task failure settings in case of failure of scheduled task, not applicable to  manually launched tasks
        #[prost(message, optional, tag = "7")]
        pub task_failure: ::core::option::Option<RetriesConfiguration>,
    }
    /// Nested message and enum types in `Scheduling`.
    pub mod scheduling {
        #[allow(clippy::derive_partial_eq_without_eq)]
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct BackupSet {
            /// BackupSet type -- one of incr, full, differential or auto.
            /// if custom scheme is used the BackupSet type should be specified
            #[prost(enumeration = "backup_set::Type", tag = "3")]
            pub r#type: i32,
            #[prost(oneof = "backup_set::Setting", tags = "1, 2")]
            pub setting: ::core::option::Option<backup_set::Setting>,
        }
        /// Nested message and enum types in `BackupSet`.
        pub mod backup_set {
            #[allow(clippy::derive_partial_eq_without_eq)]
            #[derive(Clone, PartialEq, ::prost::Message)]
            pub struct Time {
                /// Days in a week to perform a backup.
                #[prost(
                    enumeration = "super::super::Day",
                    repeated,
                    packed = "false",
                    tag = "1"
                )]
                pub weekdays: ::prost::alloc::vec::Vec<i32>,
                /// Time to repeat the backup.
                #[prost(message, repeated, tag = "2")]
                pub repeat_at: ::prost::alloc::vec::Vec<super::super::TimeOfDay>,
                /// Frequency of backup repetition.
                #[prost(message, optional, tag = "3")]
                pub repeat_every: ::core::option::Option<super::super::Interval>,
                /// The start time of the backup time interval.
                #[prost(message, optional, tag = "4")]
                pub time_from: ::core::option::Option<super::super::TimeOfDay>,
                /// The end time of the backup time interval.
                #[prost(message, optional, tag = "5")]
                pub time_to: ::core::option::Option<super::super::TimeOfDay>,
                /// Days in a month to perform a backup.
                /// Allowed values are from 1 to 31.
                #[prost(int64, repeated, packed = "false", tag = "6")]
                pub monthdays: ::prost::alloc::vec::Vec<i64>,
                /// If set to true, last day of month will activate
                /// the policy.
                #[prost(bool, tag = "7")]
                pub include_last_day_of_month: bool,
                /// Set of values. Allowed values form 1 to 12.
                #[prost(int64, repeated, packed = "false", tag = "8")]
                pub months: ::prost::alloc::vec::Vec<i64>,
                /// Possible types: `REPEATE_PERIOD_UNSPECIFIED`, `HOURLY`, `DAILY`, `WEEKLY`, `MONTHLY`.
                #[prost(enumeration = "super::super::RepeatePeriod", tag = "9")]
                pub r#type: i32,
                /// If the machine is off, launch missed tasks on boot up.
                #[prost(bool, tag = "10")]
                pub run_later: bool,
            }
            #[allow(clippy::derive_partial_eq_without_eq)]
            #[derive(Clone, PartialEq, ::prost::Message)]
            pub struct SinceLastExecTime {
                /// The interval between backups.
                #[prost(message, optional, tag = "1")]
                pub delay: ::core::option::Option<super::super::Interval>,
            }
            #[derive(
                Clone,
                Copy,
                Debug,
                PartialEq,
                Eq,
                Hash,
                PartialOrd,
                Ord,
                ::prost::Enumeration
            )]
            #[repr(i32)]
            pub enum Type {
                Unspecified = 0,
                Auto = 1,
                Full = 2,
                Incremental = 3,
                Differential = 4,
            }
            impl Type {
                /// String value of the enum field names used in the ProtoBuf definition.
                ///
                /// The values are not transformed in any way and thus are considered stable
                /// (if the ProtoBuf definition does not change) and safe for programmatic use.
                pub fn as_str_name(&self) -> &'static str {
                    match self {
                        Type::Unspecified => "TYPE_UNSPECIFIED",
                        Type::Auto => "TYPE_AUTO",
                        Type::Full => "TYPE_FULL",
                        Type::Incremental => "TYPE_INCREMENTAL",
                        Type::Differential => "TYPE_DIFFERENTIAL",
                    }
                }
                /// Creates an enum from field names used in the ProtoBuf definition.
                pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                    match value {
                        "TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                        "TYPE_AUTO" => Some(Self::Auto),
                        "TYPE_FULL" => Some(Self::Full),
                        "TYPE_INCREMENTAL" => Some(Self::Incremental),
                        "TYPE_DIFFERENTIAL" => Some(Self::Differential),
                        _ => None,
                    }
                }
            }
            #[allow(clippy::derive_partial_eq_without_eq)]
            #[derive(Clone, PartialEq, ::prost::Oneof)]
            pub enum Setting {
                #[prost(message, tag = "1")]
                Time(Time),
                #[prost(message, tag = "2")]
                SinceLastExecTime(SinceLastExecTime),
            }
        }
        /// Scheme of backups.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum Scheme {
            Unspecified = 0,
            Simple = 1,
            AlwaysFull = 2,
            AlwaysIncremental = 3,
            WeeklyIncremental = 4,
            WeeklyFullDailyIncremental = 5,
            /// Custom will require to specify schedules for full, differential
            /// and incremental backups additionally.
            Custom = 6,
            Cdp = 7,
        }
        impl Scheme {
            /// 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 {
                    Scheme::Unspecified => "SCHEME_UNSPECIFIED",
                    Scheme::Simple => "SIMPLE",
                    Scheme::AlwaysFull => "ALWAYS_FULL",
                    Scheme::AlwaysIncremental => "ALWAYS_INCREMENTAL",
                    Scheme::WeeklyIncremental => "WEEKLY_INCREMENTAL",
                    Scheme::WeeklyFullDailyIncremental => "WEEKLY_FULL_DAILY_INCREMENTAL",
                    Scheme::Custom => "CUSTOM",
                    Scheme::Cdp => "CDP",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "SCHEME_UNSPECIFIED" => Some(Self::Unspecified),
                    "SIMPLE" => Some(Self::Simple),
                    "ALWAYS_FULL" => Some(Self::AlwaysFull),
                    "ALWAYS_INCREMENTAL" => Some(Self::AlwaysIncremental),
                    "WEEKLY_INCREMENTAL" => Some(Self::WeeklyIncremental),
                    "WEEKLY_FULL_DAILY_INCREMENTAL" => {
                        Some(Self::WeeklyFullDailyIncremental)
                    }
                    "CUSTOM" => Some(Self::Custom),
                    "CDP" => Some(Self::Cdp),
                    _ => None,
                }
            }
        }
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct FileFilters {
        /// Do not backup files that match the following criteria
        #[prost(string, repeated, tag = "1")]
        pub exclusion_masks: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
        /// Backup only files that match the following criteria
        #[prost(string, repeated, tag = "2")]
        pub inclusion_masks: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    }
    /// Compression rate of the backups.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Compression {
        Unspecified = 0,
        Normal = 1,
        High = 2,
        Max = 3,
        Off = 4,
    }
    impl Compression {
        /// 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 {
                Compression::Unspecified => "COMPRESSION_UNSPECIFIED",
                Compression::Normal => "NORMAL",
                Compression::High => "HIGH",
                Compression::Max => "MAX",
                Compression::Off => "OFF",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "COMPRESSION_UNSPECIFIED" => Some(Self::Unspecified),
                "NORMAL" => Some(Self::Normal),
                "HIGH" => Some(Self::High),
                "MAX" => Some(Self::Max),
                "OFF" => Some(Self::Off),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum RepeatePeriod {
        Unspecified = 0,
        Hourly = 1,
        Daily = 2,
        Weekly = 3,
        Monthly = 4,
    }
    impl RepeatePeriod {
        /// 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 {
                RepeatePeriod::Unspecified => "REPEATE_PERIOD_UNSPECIFIED",
                RepeatePeriod::Hourly => "HOURLY",
                RepeatePeriod::Daily => "DAILY",
                RepeatePeriod::Weekly => "WEEKLY",
                RepeatePeriod::Monthly => "MONTHLY",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "REPEATE_PERIOD_UNSPECIFIED" => Some(Self::Unspecified),
                "HOURLY" => Some(Self::Hourly),
                "DAILY" => Some(Self::Daily),
                "WEEKLY" => Some(Self::Weekly),
                "MONTHLY" => Some(Self::Monthly),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Day {
        Unspecified = 0,
        Monday = 1,
        Tuesday = 2,
        Wednesday = 3,
        Thursday = 4,
        Friday = 5,
        Saturday = 6,
        Sunday = 7,
    }
    impl Day {
        /// 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 {
                Day::Unspecified => "DAY_UNSPECIFIED",
                Day::Monday => "MONDAY",
                Day::Tuesday => "TUESDAY",
                Day::Wednesday => "WEDNESDAY",
                Day::Thursday => "THURSDAY",
                Day::Friday => "FRIDAY",
                Day::Saturday => "SATURDAY",
                Day::Sunday => "SUNDAY",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "DAY_UNSPECIFIED" => Some(Self::Unspecified),
                "MONDAY" => Some(Self::Monday),
                "TUESDAY" => Some(Self::Tuesday),
                "WEDNESDAY" => Some(Self::Wednesday),
                "THURSDAY" => Some(Self::Thursday),
                "FRIDAY" => Some(Self::Friday),
                "SATURDAY" => Some(Self::Saturday),
                "SUNDAY" => Some(Self::Sunday),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ChangedBlockTracking {
        Unspecified = 0,
        UseIfEnabled = 1,
        EnableAndUse = 2,
        DoNotUse = 3,
    }
    impl ChangedBlockTracking {
        /// 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 {
                ChangedBlockTracking::Unspecified => "CHANGED_BLOCK_TRACKING_UNSPECIFIED",
                ChangedBlockTracking::UseIfEnabled => "USE_IF_ENABLED",
                ChangedBlockTracking::EnableAndUse => "ENABLE_AND_USE",
                ChangedBlockTracking::DoNotUse => "DO_NOT_USE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "CHANGED_BLOCK_TRACKING_UNSPECIFIED" => Some(Self::Unspecified),
                "USE_IF_ENABLED" => Some(Self::UseIfEnabled),
                "ENABLE_AND_USE" => Some(Self::EnableAndUse),
                "DO_NOT_USE" => Some(Self::DoNotUse),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PolicyApplication {
    /// Policy ID.
    #[prost(string, tag = "1")]
    pub policy_id: ::prost::alloc::string::String,
    /// Compute Cloud instance ID.
    #[prost(string, tag = "2")]
    pub compute_instance_id: ::prost::alloc::string::String,
    #[prost(bool, tag = "3")]
    pub enabled: bool,
    #[prost(enumeration = "policy_application::Status", tag = "4")]
    pub status: i32,
    #[prost(message, optional, tag = "5")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// If true, then the policy is in in the process of binding to the instance.
    #[prost(bool, tag = "6")]
    pub is_processing: bool,
}
/// Nested message and enum types in `PolicyApplication`.
pub mod policy_application {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Status {
        Unspecified = 0,
        /// Application is applied and everything is OK.
        Ok = 1,
        /// Application is currently running.
        Running = 2,
        /// Application is disabled.
        Disabled = 3,
    }
    impl Status {
        /// 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 {
                Status::Unspecified => "STATUS_UNSPECIFIED",
                Status::Ok => "OK",
                Status::Running => "RUNNING",
                Status::Disabled => "DISABLED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATUS_UNSPECIFIED" => Some(Self::Unspecified),
                "OK" => Some(Self::Ok),
                "RUNNING" => Some(Self::Running),
                "DISABLED" => Some(Self::Disabled),
                _ => None,
            }
        }
    }
}
/// Format of the backup in policy. For backup locations that can be browsed
/// with a file manager, the backup format determines the number of files and
/// their extension.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum Format {
    Unspecified = 0,
    /// A legacy backup format used in older versions. It's not recommended to use.
    Version11 = 1,
    /// A new format recommended in most cases for fast backup and recovery.
    Version12 = 2,
    /// Automatic version selection. Will be used version 12 unless the protection
    /// plan (policy) appends backups to the ones created by earlier product
    /// versions.
    Auto = 3,
}
impl Format {
    /// 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 {
            Format::Unspecified => "FORMAT_UNSPECIFIED",
            Format::Version11 => "VERSION_11",
            Format::Version12 => "VERSION_12",
            Format::Auto => "AUTO",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "FORMAT_UNSPECIFIED" => Some(Self::Unspecified),
            "VERSION_11" => Some(Self::Version11),
            "VERSION_12" => Some(Self::Version12),
            "AUTO" => Some(Self::Auto),
            _ => None,
        }
    }
}
/// Archive is a container that holds backups of Compute Cloud instance.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Archive {
    /// ID of the backup.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Name of the backup.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// ID of the backup vault.
    #[prost(string, tag = "3")]
    pub vault_id: ::prost::alloc::string::String,
    /// Archive attributes.
    #[prost(message, optional, tag = "4")]
    pub attributes: ::core::option::Option<archive::ArchiveAttributes>,
    /// Archive size.
    #[prost(int64, tag = "5")]
    pub size: i64,
    /// Compressed data size.
    #[prost(int64, tag = "6")]
    pub compressed_data_size: i64,
    /// Data size.
    #[prost(int64, tag = "7")]
    pub data_size: i64,
    /// Original data size.
    #[prost(int64, tag = "8")]
    pub original_data_size: i64,
    /// Logical size.
    #[prost(int64, tag = "9")]
    pub logical_size: i64,
    #[prost(enumeration = "Format", tag = "10")]
    pub format: i32,
    #[prost(message, optional, tag = "11")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    #[prost(message, optional, tag = "12")]
    pub updated_at: ::core::option::Option<::prost_types::Timestamp>,
    #[prost(message, optional, tag = "13")]
    pub last_backup_created_at: ::core::option::Option<::prost_types::Timestamp>,
    #[prost(message, optional, tag = "14")]
    pub last_seen_at: ::core::option::Option<::prost_types::Timestamp>,
    /// If this field is true, it means that any of encryption algorithm
    /// has been chosen.
    #[prost(bool, tag = "15")]
    pub protected_by_password: bool,
    #[prost(enumeration = "archive::EncryptionAlgorithm", tag = "16")]
    pub encryption_algorithm: i32,
    #[prost(enumeration = "archive::Action", repeated, tag = "20")]
    pub actions: ::prost::alloc::vec::Vec<i32>,
    /// Backup plan ID.
    #[prost(string, tag = "22")]
    pub backup_plan_id: ::prost::alloc::string::String,
    /// Backup plan name.
    #[prost(string, tag = "23")]
    pub backup_plan_name: ::prost::alloc::string::String,
    /// Backup plan description.
    #[prost(string, tag = "24")]
    pub description: ::prost::alloc::string::String,
    /// Display name, e.g. `INSTANCE_NAME - POLICY_NAME`.
    #[prost(string, tag = "25")]
    pub display_name: ::prost::alloc::string::String,
    /// Compute Cloud instance ID.
    #[prost(string, tag = "26")]
    pub compute_instance_id: ::prost::alloc::string::String,
    /// If this field is true, it means that the archive is consistent.
    #[prost(bool, tag = "27")]
    pub consistent: bool,
    /// If this field is true, it means that the archive was deleted.
    #[prost(bool, tag = "30")]
    pub deleted: bool,
    /// Resource ID.
    #[prost(string, tag = "31")]
    pub resource_id: ::prost::alloc::string::String,
}
/// Nested message and enum types in `Archive`.
pub mod archive {
    /// Archive attributes.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ArchiveAttributes {
        /// Archive attribute. Default value: `0`.
        #[prost(string, tag = "1")]
        pub aaib: ::prost::alloc::string::String,
        /// URI of the backup archive.
        #[prost(string, tag = "2")]
        pub uri: ::prost::alloc::string::String,
    }
    /// Encryption Algorithm for underlying backups:
    /// `ENCRYPTION_ALGORITHM_UNSPECIFIED`, `NONE`, `AES128`, `AES192`,
    /// `AES256`.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum EncryptionAlgorithm {
        Unspecified = 0,
        None = 1,
        Aes128 = 2,
        Aes192 = 3,
        Aes256 = 4,
    }
    impl EncryptionAlgorithm {
        /// 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 {
                EncryptionAlgorithm::Unspecified => "ENCRYPTION_ALGORITHM_UNSPECIFIED",
                EncryptionAlgorithm::None => "NONE",
                EncryptionAlgorithm::Aes128 => "AES128",
                EncryptionAlgorithm::Aes192 => "AES192",
                EncryptionAlgorithm::Aes256 => "AES256",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "ENCRYPTION_ALGORITHM_UNSPECIFIED" => Some(Self::Unspecified),
                "NONE" => Some(Self::None),
                "AES128" => Some(Self::Aes128),
                "AES192" => Some(Self::Aes192),
                "AES256" => Some(Self::Aes256),
                _ => None,
            }
        }
    }
    /// Action with archive backup: `ACTION_UNSPECIFIED`, `REFRESH`,
    /// `DELETE_BY_AGENT`.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Action {
        Unspecified = 0,
        Refresh = 1,
        DeleteByAgent = 2,
    }
    impl Action {
        /// 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 {
                Action::Unspecified => "ACTION_UNSPECIFIED",
                Action::Refresh => "REFRESH",
                Action::DeleteByAgent => "DELETE_BY_AGENT",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "ACTION_UNSPECIFIED" => Some(Self::Unspecified),
                "REFRESH" => Some(Self::Refresh),
                "DELETE_BY_AGENT" => Some(Self::DeleteByAgent),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Volume {
    /// Free space in the volume.
    #[prost(int64, tag = "1")]
    pub free_space: i64,
    /// If this field is true, it means that the volume is bootable.
    #[prost(bool, tag = "2")]
    pub is_bootable: bool,
    /// If this field is true, it means that the volume is a system volume.
    #[prost(bool, tag = "3")]
    pub is_system: bool,
    /// Volume name.
    #[prost(string, tag = "4")]
    pub name: ::prost::alloc::string::String,
    /// Volume size.
    #[prost(int64, tag = "5")]
    pub size: i64,
    /// Mount string ID.
    #[prost(string, tag = "6")]
    pub mount_strid: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Disk {
    /// Device model.
    #[prost(string, tag = "1")]
    pub device_model: ::prost::alloc::string::String,
    /// Disk name.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Disk size.
    #[prost(int64, tag = "3")]
    pub size: i64,
    #[prost(message, repeated, tag = "4")]
    pub volumes: ::prost::alloc::vec::Vec<Volume>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Backup {
    /// ID of the backup.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// ID of the backup vault.
    #[prost(string, tag = "2")]
    pub vault_id: ::prost::alloc::string::String,
    /// ID of the backup archive.
    #[prost(string, tag = "3")]
    pub archive_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "4")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    #[prost(message, optional, tag = "5")]
    pub last_seen_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Backup size.
    #[prost(int64, tag = "6")]
    pub size: i64,
    /// Deduplicated backup size.
    #[prost(int64, tag = "7")]
    pub deduplicated_size: i64,
    /// Backed up data size.
    #[prost(int64, tag = "8")]
    pub backed_up_data_size: i64,
    /// Original data size.
    #[prost(int64, tag = "9")]
    pub original_data_size: i64,
    #[prost(message, optional, tag = "10")]
    pub attributes: ::core::option::Option<backup::BackupAttributes>,
    /// Compute Cloud instance ID.
    #[prost(string, tag = "11")]
    pub compute_instance_id: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "14")]
    pub disks: ::prost::alloc::vec::Vec<Disk>,
    #[prost(enumeration = "backup::Type", tag = "15")]
    pub r#type: i32,
    /// If this field is true, it means that the backup was deleted.
    #[prost(bool, tag = "21")]
    pub deleted: bool,
    /// \[Policy\](/docs/backup/concepts/policy) ID.
    #[prost(string, tag = "22")]
    pub policy_id: ::prost::alloc::string::String,
    /// Resource ID. It identifies Compute Cloud instance in backup service.
    #[prost(string, tag = "23")]
    pub resource_id: ::prost::alloc::string::String,
}
/// Nested message and enum types in `Backup`.
pub mod backup {
    /// Backup attributes.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct BackupAttributes {
        /// Backup stream name.
        #[prost(string, tag = "1")]
        pub stream_name: ::prost::alloc::string::String,
        /// URI of the backup archive.
        #[prost(string, tag = "2")]
        pub uri: ::prost::alloc::string::String,
    }
    /// Backup type.
    /// For detailed information, please see [Backup types](/docs/backup/concepts/backup#types).
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Type {
        Unspecified = 0,
        Full = 1,
        Incremental = 2,
    }
    impl Type {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Type::Unspecified => "TYPE_UNSPECIFIED",
                Type::Full => "FULL",
                Type::Incremental => "INCREMENTAL",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "FULL" => Some(Self::Full),
                "INCREMENTAL" => Some(Self::Incremental),
                _ => None,
            }
        }
    }
}
/// BackupFile represents a single unit of file or directory system inside the backup.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BackupFile {
    /// ID of the item. Should be used as source ID in case of listing.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Might be empty if this is root directory.
    #[prost(message, optional, tag = "2")]
    pub parent_id: ::core::option::Option<::prost::alloc::string::String>,
    /// Type of the item.
    #[prost(enumeration = "backup_file::Type", tag = "3")]
    pub r#type: i32,
    /// Absolute path of the item.
    #[prost(string, tag = "4")]
    pub full_path: ::prost::alloc::string::String,
    /// Name of the directory / file.
    #[prost(string, tag = "5")]
    pub name: ::prost::alloc::string::String,
    /// Size in bytes of the item.
    #[prost(int64, tag = "6")]
    pub size: i64,
    /// Actions that might be done on the object.
    #[prost(message, optional, tag = "7")]
    pub actions: ::core::option::Option<backup_file::Actions>,
    #[prost(message, optional, tag = "8")]
    pub modified_at: ::core::option::Option<::prost_types::Timestamp>,
}
/// Nested message and enum types in `BackupFile`.
pub mod backup_file {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Actions {
        /// Allows to send request to restore item to disk
        #[prost(bool, tag = "1")]
        pub restore_to_disk: bool,
        /// Allows to move to location by id.
        #[prost(bool, tag = "2")]
        pub go_to_location: bool,
    }
    /// Type of the file.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Type {
        Unspecified = 0,
        Dir = 1,
        File = 2,
    }
    impl Type {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Type::Unspecified => "TYPE_UNSPECIFIED",
                Type::Dir => "TYPE_DIR",
                Type::File => "TYPE_FILE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "TYPE_DIR" => Some(Self::Dir),
                "TYPE_FILE" => Some(Self::File),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TenantInfo {
    /// Folder ID
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// Personal tenant id from backup provider
    #[prost(string, tag = "2")]
    pub personal_tenant_id: ::prost::alloc::string::String,
    /// User id from provider
    #[prost(string, tag = "3")]
    pub user_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Resource {
    /// Compute Cloud instance ID.
    #[prost(string, tag = "1")]
    pub compute_instance_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    #[prost(message, optional, tag = "3")]
    pub updated_at: ::core::option::Option<::prost_types::Timestamp>,
    /// If this field is true, it means that instance is online.
    #[prost(bool, tag = "4")]
    pub online: bool,
    /// If this field is true, it means that backup is enabled to instance.
    #[prost(bool, tag = "5")]
    pub enabled: bool,
    #[prost(enumeration = "resource::Status", tag = "6")]
    pub status: i32,
    /// If status value is one of `OTHER` or `FAILED`,
    /// detailed info might be stored here.
    #[prost(string, tag = "7")]
    pub status_details: ::prost::alloc::string::String,
    /// In case status is one of `BACKUPING` or `RECOVERING`,
    /// progress value might be found here.
    #[prost(int64, tag = "8")]
    pub status_progress: i64,
    #[prost(message, optional, tag = "9")]
    pub last_backup_time: ::core::option::Option<::prost_types::Timestamp>,
    #[prost(message, optional, tag = "10")]
    pub next_backup_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Resource ID is used to identify Compute Cloud instance in backup service.
    #[prost(string, tag = "11")]
    pub resource_id: ::prost::alloc::string::String,
    /// Status `is_active` shows whether current Compute Cloud instance controls Cloud Backup resource.
    /// If status `is_active` is false it means Compute Cloud instance is not able to manipulate
    /// Cloud Backup resource.
    #[prost(bool, tag = "12")]
    pub is_active: bool,
    /// Status of resource initialization in cloud backup service.
    #[prost(enumeration = "resource::InitStatus", tag = "13")]
    pub init_status: i32,
    /// Metadata to provide details about instance registration process
    /// if status is FAILED_REGISTRATION or REGISTERING
    #[prost(string, tag = "14")]
    pub metadata: ::prost::alloc::string::String,
    /// Type of resource. Could be compute VM or baremetal server.
    #[prost(enumeration = "ResourceType", tag = "15")]
    pub r#type: i32,
    /// Additional info abount tenant which resource belongs to
    #[prost(message, optional, tag = "16")]
    pub tenant_info: ::core::option::Option<TenantInfo>,
}
/// Nested message and enum types in `Resource`.
pub mod resource {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Status {
        Unspecified = 0,
        /// Compute Cloud instance is doing nothing right now.
        Idle = 1,
        /// Compute Cloud instance is currently backing up itself.
        Backuping = 2,
        /// Compute Cloud instance is currently recovering itself.
        Recovering = 3,
        /// Compute Cloud instance is in failure state, check content of
        /// `status_details` field for more information.
        Failed = 4,
        /// Unspecified state, check `status_details` field
        /// for more information.
        Other = 5,
    }
    impl Status {
        /// 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 {
                Status::Unspecified => "STATUS_UNSPECIFIED",
                Status::Idle => "IDLE",
                Status::Backuping => "BACKUPING",
                Status::Recovering => "RECOVERING",
                Status::Failed => "FAILED",
                Status::Other => "OTHER",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATUS_UNSPECIFIED" => Some(Self::Unspecified),
                "IDLE" => Some(Self::Idle),
                "BACKUPING" => Some(Self::Backuping),
                "RECOVERING" => Some(Self::Recovering),
                "FAILED" => Some(Self::Failed),
                "OTHER" => Some(Self::Other),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum InitStatus {
        Unspecified = 0,
        /// Registration of instance in cloud backups have started.
        Registering = 1,
        /// Instance is registered in cloud backups.
        Registred = 2,
        /// Instance registration failed.
        FailedRegistration = 3,
        /// Instance is deleted from cloud backup service.
        Deleted = 4,
    }
    impl InitStatus {
        /// 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 {
                InitStatus::Unspecified => "INIT_STATUS_UNSPECIFIED",
                InitStatus::Registering => "REGISTERING",
                InitStatus::Registred => "REGISTRED",
                InitStatus::FailedRegistration => "FAILED_REGISTRATION",
                InitStatus::Deleted => "DELETED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "INIT_STATUS_UNSPECIFIED" => Some(Self::Unspecified),
                "REGISTERING" => Some(Self::Registering),
                "REGISTRED" => Some(Self::Registred),
                "FAILED_REGISTRATION" => Some(Self::FailedRegistration),
                "DELETED" => Some(Self::Deleted),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Progress {
    #[prost(int64, tag = "1")]
    pub current: i64,
    #[prost(int64, tag = "2")]
    pub total: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Task {
    /// Task ID.
    #[prost(int64, tag = "1")]
    pub id: i64,
    /// Shows whether the task is cancellable.
    /// Note: task cancellation is not supported yet.
    #[prost(bool, tag = "2")]
    pub cancellable: bool,
    /// Policy ID.
    #[prost(string, tag = "3")]
    pub policy_id: ::prost::alloc::string::String,
    /// Type of the task.
    #[prost(enumeration = "task::Type", tag = "4")]
    pub r#type: i32,
    /// Task progress.
    #[prost(message, optional, tag = "5")]
    pub progress: ::core::option::Option<Progress>,
    /// Task status.
    #[prost(enumeration = "task::Status", tag = "6")]
    pub status: i32,
    #[prost(message, optional, tag = "7")]
    pub enqueued_at: ::core::option::Option<::prost_types::Timestamp>,
    #[prost(message, optional, tag = "8")]
    pub started_at: ::core::option::Option<::prost_types::Timestamp>,
    #[prost(message, optional, tag = "9")]
    pub updated_at: ::core::option::Option<::prost_types::Timestamp>,
    #[prost(message, optional, tag = "10")]
    pub completed_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Compute Cloud instance ID.
    #[prost(string, tag = "11")]
    pub compute_instance_id: ::prost::alloc::string::String,
    /// Task result code.
    #[prost(enumeration = "task::Code", tag = "12")]
    pub result_code: i32,
    /// Task error message if task finished with not OK code
    #[prost(string, tag = "13")]
    pub error: ::prost::alloc::string::String,
}
/// Nested message and enum types in `Task`.
pub mod task {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Type {
        Unspecified = 0,
        Backup = 1,
        Retention = 2,
        Recovery = 3,
        ApplyPolicy = 4,
        RevokePolicy = 5,
    }
    impl Type {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Type::Unspecified => "TYPE_UNSPECIFIED",
                Type::Backup => "BACKUP",
                Type::Retention => "RETENTION",
                Type::Recovery => "RECOVERY",
                Type::ApplyPolicy => "APPLY_POLICY",
                Type::RevokePolicy => "REVOKE_POLICY",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "BACKUP" => Some(Self::Backup),
                "RETENTION" => Some(Self::Retention),
                "RECOVERY" => Some(Self::Recovery),
                "APPLY_POLICY" => Some(Self::ApplyPolicy),
                "REVOKE_POLICY" => Some(Self::RevokePolicy),
                _ => None,
            }
        }
    }
    /// Status of task.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Status {
        Unspecified = 0,
        Enqueued = 1,
        Assigned = 2,
        Started = 3,
        Paused = 4,
        Completed = 5,
    }
    impl Status {
        /// 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 {
                Status::Unspecified => "STATUS_UNSPECIFIED",
                Status::Enqueued => "ENQUEUED",
                Status::Assigned => "ASSIGNED",
                Status::Started => "STARTED",
                Status::Paused => "PAUSED",
                Status::Completed => "COMPLETED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATUS_UNSPECIFIED" => Some(Self::Unspecified),
                "ENQUEUED" => Some(Self::Enqueued),
                "ASSIGNED" => Some(Self::Assigned),
                "STARTED" => Some(Self::Started),
                "PAUSED" => Some(Self::Paused),
                "COMPLETED" => Some(Self::Completed),
                _ => None,
            }
        }
    }
    /// Result code of task
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Code {
        Unspecified = 0,
        Ok = 1,
        Error = 2,
        Warning = 3,
        Cancelled = 4,
        Abandoned = 5,
        Timedout = 6,
    }
    impl Code {
        /// 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 {
                Code::Unspecified => "CODE_UNSPECIFIED",
                Code::Ok => "OK",
                Code::Error => "ERROR",
                Code::Warning => "WARNING",
                Code::Cancelled => "CANCELLED",
                Code::Abandoned => "ABANDONED",
                Code::Timedout => "TIMEDOUT",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "CODE_UNSPECIFIED" => Some(Self::Unspecified),
                "OK" => Some(Self::Ok),
                "ERROR" => Some(Self::Error),
                "WARNING" => Some(Self::Warning),
                "CANCELLED" => Some(Self::Cancelled),
                "ABANDONED" => Some(Self::Abandoned),
                "TIMEDOUT" => Some(Self::Timedout),
                _ => None,
            }
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ResourceType {
    Unspecified = 0,
    /// Resource is Compute Cloud VM
    Compute = 1,
    /// Resource is baremetal server
    Bms = 2,
}
impl ResourceType {
    /// 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 {
            ResourceType::Unspecified => "RESOURCE_TYPE_UNSPECIFIED",
            ResourceType::Compute => "COMPUTE",
            ResourceType::Bms => "BMS",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "RESOURCE_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
            "COMPUTE" => Some(Self::Compute),
            "BMS" => Some(Self::Bms),
            _ => None,
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListArchivesRequest {
    #[prost(oneof = "list_archives_request::Id", tags = "1, 2")]
    pub id: ::core::option::Option<list_archives_request::Id>,
}
/// Nested message and enum types in `ListArchivesRequest`.
pub mod list_archives_request {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Id {
        /// List of archives in specified folder.
        #[prost(string, tag = "1")]
        FolderId(::prost::alloc::string::String),
        /// List of archives of the specified Compute Cloud instance.
        #[prost(string, tag = "2")]
        ComputeInstanceId(::prost::alloc::string::String),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListArchivesResponse {
    #[prost(message, repeated, tag = "1")]
    pub archives: ::prost::alloc::vec::Vec<Archive>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListBackupsRequest {
    /// By which column the listing should be ordered and in which direction,
    /// format is "createdAt desc". "createdAt desc" if omitted.
    #[prost(string, tag = "5")]
    pub order_by: ::prost::alloc::string::String,
    /// Filter list by various parameters.
    /// Supported parameters are:
    /// * created_at
    ///
    /// Supported logic operators:
    /// * AND
    #[prost(string, tag = "8")]
    pub filter: ::prost::alloc::string::String,
    /// Type of resource. Could be compute VM or baremetal server.
    #[prost(enumeration = "ResourceType", tag = "9")]
    pub r#type: i32,
    /// Number of results per page.
    #[prost(int64, tag = "10")]
    pub page_size: i64,
    /// Token for the results page. Not allowed to use if listing is performed by specific policy ID.
    #[prost(string, tag = "11")]
    pub page_token: ::prost::alloc::string::String,
    #[prost(oneof = "list_backups_request::Id", tags = "1, 2, 3, 4, 6, 7")]
    pub id: ::core::option::Option<list_backups_request::Id>,
}
/// Nested message and enum types in `ListBackupsRequest`.
pub mod list_backups_request {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ArchiveParameters {
        /// Archive ID.
        #[prost(string, tag = "1")]
        pub archive_id: ::prost::alloc::string::String,
        /// Folder ID.
        #[prost(string, tag = "2")]
        pub folder_id: ::prost::alloc::string::String,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct InstancePolicy {
        /// Compute Cloud instance ID.
        #[prost(string, tag = "1")]
        pub compute_instance_id: ::prost::alloc::string::String,
        /// Policy ID.
        #[prost(string, tag = "2")]
        pub policy_id: ::prost::alloc::string::String,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Id {
        /// List backups that belongs to specific Compute Cloud instance.
        #[prost(string, tag = "1")]
        ComputeInstanceId(::prost::alloc::string::String),
        /// List backups that belongs to specific archive of specific folder.
        #[prost(message, tag = "2")]
        Archive(ArchiveParameters),
        /// List backups that belongs to specific folder.
        #[prost(string, tag = "3")]
        FolderId(::prost::alloc::string::String),
        /// List backups that belongs to specific instance and policy at the same time.
        #[prost(message, tag = "4")]
        InstancePolicy(InstancePolicy),
        /// List backups by specific resource ID.
        #[prost(string, tag = "6")]
        ResourceId(::prost::alloc::string::String),
        /// List backups by specific policy ID.
        #[prost(string, tag = "7")]
        PolicyId(::prost::alloc::string::String),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListBackupsResponse {
    #[prost(message, repeated, tag = "1")]
    pub backups: ::prost::alloc::vec::Vec<Backup>,
    /// Token for the next results page.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListFilesRequest {
    /// Folder ID.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// Backup ID.
    #[prost(string, tag = "2")]
    pub backup_id: ::prost::alloc::string::String,
    /// Empty source will list disks of the backup.
    #[prost(string, tag = "3")]
    pub source_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListFilesResponse {
    #[prost(message, repeated, tag = "1")]
    pub files: ::prost::alloc::vec::Vec<BackupFile>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetBackupRequest {
    /// Backup ID.
    #[prost(string, tag = "1")]
    pub backup_id: ::prost::alloc::string::String,
    /// Folder ID.
    #[prost(string, tag = "2")]
    pub folder_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StartRecoveryRequest {
    /// Destination Compute Cloud instance ID to which backup should be applied.
    #[prost(string, tag = "1")]
    pub compute_instance_id: ::prost::alloc::string::String,
    /// Backup ID that will be applied to destination Compute Cloud instance.
    #[prost(string, tag = "2")]
    pub backup_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StartRecoveryMetadata {
    /// Progress of the backup process.
    #[prost(double, tag = "1")]
    pub progress_percentage: f64,
    /// Source Backup ID that will be applied.
    #[prost(string, tag = "2")]
    pub src_backup_id: ::prost::alloc::string::String,
    /// Destination Compute Cloud instance ID to which backup will be applied.
    #[prost(string, tag = "3")]
    pub dst_compute_instance_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TargetPathOriginal {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TargetPathCustom {
    /// Custom folder for file recovery.
    #[prost(string, tag = "1")]
    pub path: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FilesRecoveryOptions {
    /// Overwrite options declares the behavior for files that already exists on the file system.
    #[prost(enumeration = "files_recovery_options::Overwrite", tag = "1")]
    pub overwrite: i32,
    /// specifies whether the recovery plan is able to reboot host if needed.
    #[prost(bool, tag = "2")]
    pub reboot_if_needed: bool,
    /// Path strategy for selected files.
    #[prost(oneof = "files_recovery_options::Type", tags = "100, 101")]
    pub r#type: ::core::option::Option<files_recovery_options::Type>,
}
/// Nested message and enum types in `FilesRecoveryOptions`.
pub mod files_recovery_options {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Overwrite {
        /// Unspecified value treated as Overwrite all
        Unspecified = 0,
        /// All overwrites all existing files by recovered ones.
        All = 1,
        /// Older overwrites older files only.
        Older = 2,
        /// None does not overwrites files at all.
        None = 3,
    }
    impl Overwrite {
        /// 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 {
                Overwrite::Unspecified => "OVERWRITE_UNSPECIFIED",
                Overwrite::All => "OVERWRITE_ALL",
                Overwrite::Older => "OVERWRITE_OLDER",
                Overwrite::None => "OVERWRITE_NONE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "OVERWRITE_UNSPECIFIED" => Some(Self::Unspecified),
                "OVERWRITE_ALL" => Some(Self::All),
                "OVERWRITE_OLDER" => Some(Self::Older),
                "OVERWRITE_NONE" => Some(Self::None),
                _ => None,
            }
        }
    }
    /// Path strategy for selected files.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Type {
        /// Keep original paths of files.
        #[prost(message, tag = "100")]
        Original(super::TargetPathOriginal),
        /// Set custom folder for file recovery.
        #[prost(message, tag = "101")]
        Custom(super::TargetPathCustom),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StartFilesRecoveryRequest {
    /// Destination instance ID.
    #[prost(string, tag = "1")]
    pub compute_instance_id: ::prost::alloc::string::String,
    /// Backup ID.
    #[prost(string, tag = "2")]
    pub backup_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "3")]
    pub opts: ::core::option::Option<FilesRecoveryOptions>,
    #[prost(string, repeated, tag = "4")]
    pub source_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StartFilesRecoveryMetadata {
    #[prost(double, tag = "1")]
    pub progress_percentage: f64,
    /// Destination instance ID.
    #[prost(string, tag = "2")]
    pub compute_instance_id: ::prost::alloc::string::String,
    /// Backup ID.
    #[prost(string, tag = "3")]
    pub backup_id: ::prost::alloc::string::String,
    #[prost(string, repeated, tag = "4")]
    pub source_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteBackupRequest {
    /// Compute Cloud instance ID of the Backup.
    #[prost(string, tag = "1")]
    pub compute_instance_id: ::prost::alloc::string::String,
    /// Backup ID that should be deleted.
    #[prost(string, tag = "2")]
    pub backup_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteBackupMetadata {
    /// Compute Cloud instance ID of the Backup.
    #[prost(string, tag = "1")]
    pub compute_instance_id: ::prost::alloc::string::String,
    /// Backup ID that should be deleted.
    #[prost(string, tag = "2")]
    pub backup_id: ::prost::alloc::string::String,
}
/// must be specified archive_id and folder/instance_id
/// or pair of policy id and instance_id
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteArchiveRequest {
    /// Archive ID that should be deleted.
    #[prost(string, tag = "1")]
    pub archive_id: ::prost::alloc::string::String,
    /// Folder ID of the archive to delete.
    #[prost(string, tag = "2")]
    pub folder_id: ::prost::alloc::string::String,
    /// Instance ID of the Archive.
    #[prost(string, tag = "3")]
    pub instance_id: ::prost::alloc::string::String,
    /// Policy ID of the Archive.
    #[prost(string, tag = "4")]
    pub policy_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteArchiveMetadata {
    /// Archive ID that should be deleted.
    #[prost(string, tag = "1")]
    pub archive_id: ::prost::alloc::string::String,
    /// Folder ID of the archive.
    #[prost(string, tag = "2")]
    pub folder_id: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod backup_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// A set of methods for managing [backups](/docs/backup/concepts/backup).
    #[derive(Debug, Clone)]
    pub struct BackupServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl BackupServiceClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> BackupServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> BackupServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + Send + Sync,
        {
            BackupServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// List backups using filters.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListBackupsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListBackupsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.backup.v1.BackupService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.backup.v1.BackupService", "List"));
            self.inner.unary(req, path, codec).await
        }
        /// List archives that holds backups for specified folder or
        /// specified [Compute Cloud instance](/docs/backup/concepts/vm-connection#os).
        pub async fn list_archives(
            &mut self,
            request: impl tonic::IntoRequest<super::ListArchivesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListArchivesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.backup.v1.BackupService/ListArchives",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.backup.v1.BackupService",
                        "ListArchives",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// ListFiles of the backup.
        pub async fn list_files(
            &mut self,
            request: impl tonic::IntoRequest<super::ListFilesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListFilesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.backup.v1.BackupService/ListFiles",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.backup.v1.BackupService", "ListFiles"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Get backup by its id.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetBackupRequest>,
        ) -> std::result::Result<tonic::Response<super::Backup>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.backup.v1.BackupService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.backup.v1.BackupService", "Get"));
            self.inner.unary(req, path, codec).await
        }
        /// Start recovery process of specified backup to specific Compute Cloud instance.
        ///
        /// For details, see [Restoring a VM from a backup](/docs/backup/operations/backup-vm/recover).
        pub async fn start_recovery(
            &mut self,
            request: impl tonic::IntoRequest<super::StartRecoveryRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.backup.v1.BackupService/StartRecovery",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.backup.v1.BackupService",
                        "StartRecovery",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// StartFilesRecovery runs recovery process of selected files to specific Compute Cloud instance.
        pub async fn start_files_recovery(
            &mut self,
            request: impl tonic::IntoRequest<super::StartFilesRecoveryRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.backup.v1.BackupService/StartFilesRecovery",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.backup.v1.BackupService",
                        "StartFilesRecovery",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Delete specific backup.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteBackupRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.backup.v1.BackupService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.backup.v1.BackupService", "Delete"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Delete specific archive.
        pub async fn delete_archive(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteArchiveRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.backup.v1.BackupService/DeleteArchive",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.backup.v1.BackupService",
                        "DeleteArchive",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListPoliciesRequest {
    /// Folder ID. Either Folder ID or Compute Cloud instance ID should be set.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// Compute Cloud instance ID. Either Folder ID or Compute Cloud instance ID should be set.
    #[prost(string, tag = "2")]
    pub compute_instance_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListPoliciesResponse {
    #[prost(message, repeated, tag = "1")]
    pub policies: ::prost::alloc::vec::Vec<Policy>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreatePolicyRequest {
    /// Folder ID.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// Policy name.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "3")]
    pub settings: ::core::option::Option<PolicySettings>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreatePolicyMetadata {
    /// Policy ID.
    #[prost(string, tag = "1")]
    pub policy_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetPolicyRequest {
    /// Policy ID.
    #[prost(string, tag = "1")]
    pub policy_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdatePolicyRequest {
    /// Policy ID.
    #[prost(string, tag = "1")]
    pub policy_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub settings: ::core::option::Option<PolicySettings>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdatePolicyMetadata {
    /// Policy ID.
    #[prost(string, tag = "1")]
    pub policy_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeletePolicyRequest {
    /// Policy ID.
    #[prost(string, tag = "1")]
    pub policy_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeletePolicyMetadata {
    /// Policy ID.
    #[prost(string, tag = "1")]
    pub policy_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ApplyPolicyRequest {
    /// Policy ID.
    #[prost(string, tag = "1")]
    pub policy_id: ::prost::alloc::string::String,
    /// Compute Cloud instance ID.
    #[prost(string, tag = "2")]
    pub compute_instance_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ApplyPolicyMetadata {
    /// Policy ID.
    #[prost(string, tag = "1")]
    pub policy_id: ::prost::alloc::string::String,
    /// Compute Cloud instance ID.
    #[prost(string, tag = "2")]
    pub compute_instance_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListApplicationsRequest {
    /// If true, also returns applications that in the process of binding.
    #[prost(bool, tag = "4")]
    pub show_processing: bool,
    #[prost(oneof = "list_applications_request::Id", tags = "1, 2, 3")]
    pub id: ::core::option::Option<list_applications_request::Id>,
}
/// Nested message and enum types in `ListApplicationsRequest`.
pub mod list_applications_request {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Id {
        /// Folder ID.
        #[prost(string, tag = "1")]
        FolderId(::prost::alloc::string::String),
        /// Policy ID.
        #[prost(string, tag = "2")]
        PolicyId(::prost::alloc::string::String),
        /// Compute Cloud instance ID.
        #[prost(string, tag = "3")]
        ComputeInstanceId(::prost::alloc::string::String),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListApplicationsResponse {
    #[prost(message, repeated, tag = "1")]
    pub applications: ::prost::alloc::vec::Vec<PolicyApplication>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExecuteRequest {
    /// Policy ID.
    #[prost(string, tag = "1")]
    pub policy_id: ::prost::alloc::string::String,
    /// Compute Cloud instance ID.
    #[prost(string, tag = "2")]
    pub compute_instance_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExecuteMetadata {
    /// Policy ID.
    #[prost(string, tag = "1")]
    pub policy_id: ::prost::alloc::string::String,
    /// Compute Cloud instance ID.
    #[prost(string, tag = "2")]
    pub compute_instance_id: ::prost::alloc::string::String,
    /// Progress of the backup process.
    #[prost(double, tag = "3")]
    pub progress_percentage: f64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RevokeRequest {
    /// Policy ID.
    #[prost(string, tag = "1")]
    pub policy_id: ::prost::alloc::string::String,
    /// Compute Cloud instance ID.
    #[prost(string, tag = "2")]
    pub compute_instance_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RevokeMetadata {
    /// Policy ID.
    #[prost(string, tag = "1")]
    pub policy_id: ::prost::alloc::string::String,
    /// Compute Cloud instance ID.
    #[prost(string, tag = "2")]
    pub compute_instance_id: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod policy_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// A set of methods for managing [policies](/docs/backup/concepts/policy).
    #[derive(Debug, Clone)]
    pub struct PolicyServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl PolicyServiceClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> PolicyServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> PolicyServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + Send + Sync,
        {
            PolicyServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// List [policies](/docs/backup/concepts/policy) of specified folder.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListPoliciesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListPoliciesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.backup.v1.PolicyService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.backup.v1.PolicyService", "List"));
            self.inner.unary(req, path, codec).await
        }
        /// Create a new policy.
        ///
        /// For detailed information, please see [Creating a backup policy](/docs/backup/operations/policy-vm/create).
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreatePolicyRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.backup.v1.PolicyService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.backup.v1.PolicyService", "Create"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Get specific policy.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetPolicyRequest>,
        ) -> std::result::Result<tonic::Response<super::Policy>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.backup.v1.PolicyService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.backup.v1.PolicyService", "Get"));
            self.inner.unary(req, path, codec).await
        }
        /// Update specific policy.
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdatePolicyRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.backup.v1.PolicyService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.backup.v1.PolicyService", "Update"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Delete specific policy.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeletePolicyRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.backup.v1.PolicyService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.backup.v1.PolicyService", "Delete"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Apply policy to [Compute Cloud instance](/docs/backup/concepts/vm-connection#os).
        pub async fn apply(
            &mut self,
            request: impl tonic::IntoRequest<super::ApplyPolicyRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.backup.v1.PolicyService/Apply",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.backup.v1.PolicyService", "Apply"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// List applied policies using filters.
        pub async fn list_applications(
            &mut self,
            request: impl tonic::IntoRequest<super::ListApplicationsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListApplicationsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.backup.v1.PolicyService/ListApplications",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.backup.v1.PolicyService",
                        "ListApplications",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Run policy on specific Compute Cloud instance. That will create backup
        /// according selected policy. In order to perform this action, policy should be
        /// applied to the Compute Cloud instance.
        pub async fn execute(
            &mut self,
            request: impl tonic::IntoRequest<super::ExecuteRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.backup.v1.PolicyService/Execute",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.backup.v1.PolicyService", "Execute"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Revoke policy from Compute Cloud instance.
        pub async fn revoke(
            &mut self,
            request: impl tonic::IntoRequest<super::RevokeRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.backup.v1.PolicyService/Revoke",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.backup.v1.PolicyService", "Revoke"),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ActivateProviderRequest {
    /// Activate provider for Folder iD.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// Activate specific provider by name.
    ///
    /// For more information, please see \[activate-provider\](/docs/backup/quickstart#activate-provider)
    #[prost(string, tag = "3")]
    pub name: ::prost::alloc::string::String,
    /// Don't create default policies while activating the provider.
    #[prost(bool, tag = "4")]
    pub skip_default_policy: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ActivateProviderMetadata {
    /// Activate provider for folder specified by ID.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListActivatedProvidersRequest {
    /// ID of the folder to find out the backup provider.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListActivatedProvidersResponse {
    /// Folder ID.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// Name of the backup provider.
    #[prost(string, repeated, tag = "3")]
    pub names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Generated client implementations.
pub mod provider_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// A set of methods for managing [backup providers](/docs/backup/concepts/#providers).
    #[derive(Debug, Clone)]
    pub struct ProviderServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ProviderServiceClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> ProviderServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> ProviderServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + Send + Sync,
        {
            ProviderServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Activate provider for specified client.
        pub async fn activate(
            &mut self,
            request: impl tonic::IntoRequest<super::ActivateProviderRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.backup.v1.ProviderService/Activate",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.backup.v1.ProviderService", "Activate"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// List activated providers for specified client.
        pub async fn list_activated(
            &mut self,
            request: impl tonic::IntoRequest<super::ListActivatedProvidersRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListActivatedProvidersResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.backup.v1.ProviderService/ListActivated",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.backup.v1.ProviderService",
                        "ListActivated",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListResourcesRequest {
    /// Folder ID.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// Number of results per page.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Token for the results page.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Type of resource. Could be compute VM or baremetal server.
    #[prost(enumeration = "ResourceType", tag = "4")]
    pub r#type: i32,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListResourcesResponse {
    /// Set of resource parameters.
    #[prost(message, repeated, tag = "1")]
    pub resources: ::prost::alloc::vec::Vec<Resource>,
    /// Token for the next results page.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetResourceRequest {
    /// Compute Cloud instance ID.
    #[prost(string, tag = "1")]
    pub compute_instance_id: ::prost::alloc::string::String,
    /// If flag is set tenant informantion would be added to the response.
    #[prost(bool, tag = "2")]
    pub include_tenant_info: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetResourceResponse {
    /// Set of resource parameters.
    #[prost(message, optional, tag = "1")]
    pub resource: ::core::option::Option<Resource>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteResourceRequest {
    /// Compute Cloud instance ID.
    #[prost(string, tag = "1")]
    pub compute_instance_id: ::prost::alloc::string::String,
    /// Resource ID is used to identify Compute Cloud instance in backup service.
    #[prost(string, tag = "2")]
    pub resource_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteResourceMetadata {
    /// Compute Cloud instance ID.
    #[prost(string, tag = "1")]
    pub compute_instance_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListTasksRequest {
    /// Compute Cloud instance ID.
    #[prost(string, tag = "1")]
    pub compute_instance_id: ::prost::alloc::string::String,
    /// Number of results per page.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Token for the results page.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListTasksResponse {
    /// Set of tasks parameters.
    #[prost(message, repeated, tag = "1")]
    pub tasks: ::prost::alloc::vec::Vec<Task>,
    /// Token for the next results page.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListDirectoryRequest {
    /// Folder ID.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// Compute Cloud instance ID.
    #[prost(string, tag = "2")]
    pub compute_instance_id: ::prost::alloc::string::String,
    /// Path to list items in.
    #[prost(string, tag = "3")]
    pub path: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListDirectoryResponse {
    #[prost(message, repeated, tag = "1")]
    pub items: ::prost::alloc::vec::Vec<list_directory_response::FilesystemItem>,
}
/// Nested message and enum types in `ListDirectoryResponse`.
pub mod list_directory_response {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct FilesystemItem {
        /// Item name.
        #[prost(string, tag = "1")]
        pub name: ::prost::alloc::string::String,
        /// Might be Volume, Directory of File.
        #[prost(enumeration = "filesystem_item::Type", tag = "2")]
        pub r#type: i32,
        /// Might be Directory or File.
        #[prost(enumeration = "filesystem_item::Type", tag = "3")]
        pub file_type: i32,
        #[prost(int64, tag = "4")]
        pub size: i64,
    }
    /// Nested message and enum types in `FilesystemItem`.
    pub mod filesystem_item {
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum Type {
            Unspecified = 0,
            Volume = 1,
            Directory = 2,
            File = 3,
        }
        impl Type {
            /// String value of the enum field names used in the ProtoBuf definition.
            ///
            /// The values are not transformed in any way and thus are considered stable
            /// (if the ProtoBuf definition does not change) and safe for programmatic use.
            pub fn as_str_name(&self) -> &'static str {
                match self {
                    Type::Unspecified => "TYPE_UNSPECIFIED",
                    Type::Volume => "VOLUME",
                    Type::Directory => "DIRECTORY",
                    Type::File => "FILE",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                    "VOLUME" => Some(Self::Volume),
                    "DIRECTORY" => Some(Self::Directory),
                    "FILE" => Some(Self::File),
                    _ => None,
                }
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateDirectoryRequest {
    /// Folder ID.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// Compute Cloud instance ID.
    #[prost(string, tag = "2")]
    pub compute_instance_id: ::prost::alloc::string::String,
    /// Path to create directory in.
    #[prost(string, tag = "3")]
    pub path: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateDirectoryMetadata {
    /// Compute Cloud instance ID.
    #[prost(string, tag = "1")]
    pub compute_instance_id: ::prost::alloc::string::String,
    /// Path to create directory metadata in.
    #[prost(string, tag = "2")]
    pub path: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListResourceOperationsRequest {
    /// Compute Cloud instance ID.
    #[prost(string, tag = "1")]
    pub compute_instance_id: ::prost::alloc::string::String,
    /// Number of results per page.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Token for the results page.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListResourceOperationsResponse {
    /// List of operations for the specified instance.
    #[prost(message, repeated, tag = "1")]
    pub operations: ::prost::alloc::vec::Vec<super::super::operation::Operation>,
    /// Token for the next results page.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod resource_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// A set of methods for managing backup resources: [Compute Cloud instances](/docs/backup/concepts/vm-connection#os).
    #[derive(Debug, Clone)]
    pub struct ResourceServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ResourceServiceClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> ResourceServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> ResourceServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + Send + Sync,
        {
            ResourceServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// List resources: Compute Cloud instances.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListResourcesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListResourcesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.backup.v1.ResourceService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.backup.v1.ResourceService", "List"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Get specific Compute Cloud instance.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetResourceRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetResourceResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.backup.v1.ResourceService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.backup.v1.ResourceService", "Get"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Delete specific Compute Cloud instance from Cloud Backup. It does not delete
        /// instance from Cloud Compute service.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteResourceRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.backup.v1.ResourceService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.backup.v1.ResourceService", "Delete"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// List tasks of resources.
        pub async fn list_tasks(
            &mut self,
            request: impl tonic::IntoRequest<super::ListTasksRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListTasksResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.backup.v1.ResourceService/ListTasks",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.backup.v1.ResourceService",
                        "ListTasks",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// ListDirectory returns all subdirectories found in requested directory identified
        /// by the id.
        pub async fn list_directory(
            &mut self,
            request: impl tonic::IntoRequest<super::ListDirectoryRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListDirectoryResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.backup.v1.ResourceService/ListDirectory",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.backup.v1.ResourceService",
                        "ListDirectory",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// CreateDirectory creates new directory by requested path.
        pub async fn create_directory(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateDirectoryRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.backup.v1.ResourceService/CreateDirectory",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.backup.v1.ResourceService",
                        "CreateDirectory",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// ListOperations return all operations in backup service for given instance
        pub async fn list_operations(
            &mut self,
            request: impl tonic::IntoRequest<super::ListResourceOperationsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListResourceOperationsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.backup.v1.ResourceService/ListOperations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.backup.v1.ResourceService",
                        "ListOperations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}