/// Backup as stored in Platform log. It's used to log the details of
/// a createBackup/updateBackup request, so only fields that can be taken
/// from API calls are included here.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LoggedBackup {
    /// A set of custom labels supplied by user.
    #[prost(map = "string, string", tag = "1")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// delete_lock_days specifies the number of days from the create_time of this
    /// Backup before which deletion will be blocked.
    #[prost(int32, tag = "2")]
    pub delete_lock_days: i32,
    /// retain_days specifies the desired number of days from the create_time of
    /// this Backup after which it will be automatically deleted.
    #[prost(int32, tag = "3")]
    pub retain_days: i32,
    /// User specified descriptive string for this Backup.
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
    /// Current state of the Backup
    #[prost(enumeration = "logged_backup::State", tag = "5")]
    pub state: i32,
    /// Human-readable description of why the backup is in the current `state`.
    #[prost(string, tag = "6")]
    pub state_reason: ::prost::alloc::string::String,
}
/// Nested message and enum types in `LoggedBackup`.
pub mod logged_backup {
    /// State
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        /// The Backup resource is in the process of being created.
        Unspecified = 0,
        /// The Backup resource has been created and the associated BackupJob
        /// Kubernetes resource has been injected into the source cluster.
        Creating = 1,
        /// The gkebackup agent in the cluster has begun executing the backup
        /// operation.
        InProgress = 2,
        /// The backup operation has completed successfully.
        Succeeded = 3,
        /// The backup operation has failed.
        Failed = 4,
        /// This Backup resource (and its associated artifacts) is in the process
        /// of being deleted.
        Deleting = 5,
    }
    impl State {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                State::Unspecified => "STATE_UNSPECIFIED",
                State::Creating => "CREATING",
                State::InProgress => "IN_PROGRESS",
                State::Succeeded => "SUCCEEDED",
                State::Failed => "FAILED",
                State::Deleting => "DELETING",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATE_UNSPECIFIED" => Some(Self::Unspecified),
                "CREATING" => Some(Self::Creating),
                "IN_PROGRESS" => Some(Self::InProgress),
                "SUCCEEDED" => Some(Self::Succeeded),
                "FAILED" => Some(Self::Failed),
                "DELETING" => Some(Self::Deleting),
                _ => None,
            }
        }
    }
}
/// Namespaces, list of namespaces
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Namespaces {
    /// namespaces
    #[prost(string, repeated, tag = "1")]
    pub namespaces: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// NamespacedName
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NamespacedName {
    /// the namespace of the resource in Kubernetes
    #[prost(string, tag = "1")]
    pub namespace: ::prost::alloc::string::String,
    /// the name of the resource in Kubernetes
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
}
/// NamespacedNames
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NamespacedNames {
    /// a list of namespaced names in Kubernetes
    #[prost(message, repeated, tag = "1")]
    pub namespaced_names: ::prost::alloc::vec::Vec<NamespacedName>,
}
/// Encryption key.
/// This only contains the key metadata, and no key material.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EncryptionKey {
    /// Google KMS encryption key in the format:
    /// projects/<project>/locations/<location>/keyRings/<key-ring>/cryptoKeys/<key>
    #[prost(string, tag = "1")]
    pub gcp_kms_encryption_key: ::prost::alloc::string::String,
}
/// BackupPlan as stored in Platform log. It's used to log the details of
/// a createBackupPlan/updateBackupPlan request, so only fields that can be taken
/// from user input are included here.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LoggedBackupPlan {
    /// User specified descriptive string for this BackupPlan.
    #[prost(string, tag = "1")]
    pub description: ::prost::alloc::string::String,
    /// GCP resource name of the source cluster for this BackupPlan.
    #[prost(string, tag = "2")]
    pub cluster: ::prost::alloc::string::String,
    /// RetentionPolicy governs lifecycle of Backups created under this plan.
    #[prost(message, optional, tag = "3")]
    pub retention_policy: ::core::option::Option<logged_backup_plan::RetentionPolicy>,
    /// A set of custom labels supplied by user.
    #[prost(map = "string, string", tag = "4")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Defines scheduled Backup creation under this BackupPlan.
    #[prost(message, optional, tag = "5")]
    pub backup_schedule: ::core::option::Option<logged_backup_plan::Schedule>,
    /// A flag indicates whether the plan has been deactivated.
    #[prost(bool, tag = "6")]
    pub deactivated: bool,
    /// Defines backup configuration of this BackupPlan.
    #[prost(message, optional, tag = "7")]
    pub backup_config: ::core::option::Option<logged_backup_plan::BackupConfig>,
}
/// Nested message and enum types in `LoggedBackupPlan`.
pub mod logged_backup_plan {
    /// RentionPolicy is an inner message type to define:
    /// 1. When to automatically delete Backups created under this BackupPlan
    /// 2. A plan level minimum Backup retain days which blocks deletion
    /// 3. Lock to disallow any policy updates
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RetentionPolicy {
        /// Number of days during which deletion of a Backup created under this
        /// BackupPlan will be blocked.
        #[prost(int32, tag = "1")]
        pub backup_delete_lock_days: i32,
        /// Number of days after which the service will delete a Backup.
        /// If specified, a Backup created under this BackupPlan will be
        /// automatically deleted after its age reaches create_time +
        /// backup_retain_days.
        #[prost(int32, tag = "2")]
        pub backup_retain_days: i32,
        /// A flag denotes that the retention policy of this BackupPlan is locked.
        /// If set to True, no further update is allowed on this policy, including
        /// the 'locked' field itself.
        /// Default to False.
        #[prost(bool, tag = "3")]
        pub locked: bool,
    }
    /// Schedule, an inner message type defines a cron schedule.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Schedule {
        /// A cron style string schedule on which an operation will be executed.
        #[prost(string, tag = "1")]
        pub cron_schedule: ::prost::alloc::string::String,
        /// A flag to toggle scheduled operation.
        #[prost(bool, tag = "2")]
        pub paused: bool,
    }
    /// BackupConfig, an inner message type defines the configuration of creating
    /// a backup from this BackupPlan
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct BackupConfig {
        /// A boolean flag specifies whether volume data should be backed up
        #[prost(bool, tag = "4")]
        pub include_volume_data: bool,
        /// A boolean flag specifies whether secrets should be backed up
        #[prost(bool, tag = "5")]
        pub include_secrets: bool,
        /// Custom encryption key. For preview, support GCP KMS only.
        /// This only contains the key metadata, and no key material.
        #[prost(message, optional, tag = "6")]
        pub encryption_key: ::core::option::Option<super::EncryptionKey>,
        #[prost(oneof = "backup_config::BackupScope", tags = "1, 2, 3")]
        pub backup_scope: ::core::option::Option<backup_config::BackupScope>,
    }
    /// Nested message and enum types in `BackupConfig`.
    pub mod backup_config {
        #[allow(clippy::derive_partial_eq_without_eq)]
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum BackupScope {
            /// If set to true, backup whole cluster
            #[prost(bool, tag = "1")]
            AllNamespaces(bool),
            /// If set, backup the list of namespaces
            #[prost(message, tag = "2")]
            SelectedNamespaces(super::super::Namespaces),
            /// If set, backup the list of applications
            #[prost(message, tag = "3")]
            SelectedApplications(super::super::NamespacedNames),
        }
    }
}
/// Restore as stored in Platform log. It's used to log the update details of a
/// updateRestore request, so only mutable and non-output_only fields are
/// included here..
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LoggedRestore {
    /// Full name of the Backup resource this Restore resource used to restore
    /// from. Format: projects/*/locations/*/backupPlans/*/backups/*.
    #[prost(string, tag = "1")]
    pub backup: ::prost::alloc::string::String,
    /// GCP Labels.
    #[prost(map = "string, string", tag = "2")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// User specified descriptive string for this Restore.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// The current state of the Restore.
    #[prost(enumeration = "logged_restore::State", tag = "4")]
    pub state: i32,
    /// Human-readable description of why the Restore is in its current state.
    #[prost(string, tag = "5")]
    pub state_reason: ::prost::alloc::string::String,
}
/// Nested message and enum types in `LoggedRestore`.
pub mod logged_restore {
    /// Possible values for state of the Restore.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        /// The Restore resource is in the process of being created.
        Unspecified = 0,
        /// The Restore resource has been created and the associated RestoreJob
        /// Kubernetes resource has been injected into target cluster.
        Creating = 1,
        /// The gkebackup agent in the cluster has begun executing the restore
        /// operation.
        InProgress = 2,
        /// The restore operation has completed successfully. Restored workloads may
        /// not yet be operational.
        Succeeded = 3,
        /// The restore operation has failed.
        Failed = 4,
        /// This Restore resource is in the process of being deleted.
        Deleting = 5,
    }
    impl State {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                State::Unspecified => "STATE_UNSPECIFIED",
                State::Creating => "CREATING",
                State::InProgress => "IN_PROGRESS",
                State::Succeeded => "SUCCEEDED",
                State::Failed => "FAILED",
                State::Deleting => "DELETING",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATE_UNSPECIFIED" => Some(Self::Unspecified),
                "CREATING" => Some(Self::Creating),
                "IN_PROGRESS" => Some(Self::InProgress),
                "SUCCEEDED" => Some(Self::Succeeded),
                "FAILED" => Some(Self::Failed),
                "DELETING" => Some(Self::Deleting),
                _ => None,
            }
        }
    }
}
/// RestorePlan as stored in Platform log. It's used to log the details of
/// a createRestorePlan/updateRestorePlan request, so only fields that can be
/// taken from user input are included here.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LoggedRestorePlan {
    /// User specified descriptive string for this RestorePlan.
    #[prost(string, tag = "1")]
    pub description: ::prost::alloc::string::String,
    /// The BackupPlan from which Backups may be used as the source
    /// for Restores created via this RestorePlan.
    /// Format: projects/*/locations/*/backupPlans/*.
    #[prost(string, tag = "2")]
    pub backup_plan: ::prost::alloc::string::String,
    /// The target cluster into which Restores created via this RestorePlan
    /// will restore data. NOTE: the cluster's region must be the same as the
    /// RestorePlan.
    /// Possible formats:
    ///    1. projects/*/locations/*/clusters/*
    ///    2. projects/*/zones/*/clusters/*
    #[prost(string, tag = "3")]
    pub cluster: ::prost::alloc::string::String,
    /// Configuration of Restores created via this RestorePlan.
    #[prost(message, optional, tag = "4")]
    pub restore_config: ::core::option::Option<RestoreConfig>,
    /// A set of custom labels supplied by user.
    #[prost(map = "string, string", tag = "5")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
/// Configuration of a restore.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RestoreConfig {
    /// Specifies the mechanism to be used to restore volume data.
    /// Default: VOLUME_DATA_RESTORE_POLICY_UNSPECIFIED (will be treated as
    /// NO_VOLUME_DATA_RESTORATION).
    #[prost(enumeration = "restore_config::VolumeDataRestorePolicy", tag = "1")]
    pub volume_data_restore_policy: i32,
    /// Defines the behavior for handling the situation where cluster-scoped
    /// resources being restored already exist in the target cluster. This MUST be
    /// set to a value other than CLUSTER_RESOURCE_CONFLICT_POLICY_UNSPECIFIED if
    /// cluster_resource_restore_scope is not empty.
    #[prost(enumeration = "restore_config::ClusterResourceConflictPolicy", tag = "2")]
    pub cluster_resource_conflict_policy: i32,
    /// Defines the behavior for handling the situation where sets of namespaced
    /// resources being restored already exist in the target cluster. This MUST be
    /// set to a value other than NAMESPACED_RESOURCE_RESTORE_MODE_UNSPECIFIED if
    /// any namespaced restoration is configured via
    /// namespaced_resource_restore_scope .
    #[prost(enumeration = "restore_config::NamespacedResourceRestoreMode", tag = "3")]
    pub namespaced_resource_restore_mode: i32,
    /// Identifies the cluster-scoped resources to restore from the Backup.
    /// Not specifying it means NO cluster resource will be restored.
    #[prost(message, optional, tag = "4")]
    pub cluster_resource_restore_scope: ::core::option::Option<
        restore_config::ClusterResourceRestoreScope,
    >,
    /// A list of transformation rules to be applied against Kubernetes resources
    /// as they are selected for restoration from a Backup. Rules are executed in
    /// order defined - this order matters, as changes made by a rule may impact
    /// the filtering logic of subsequent rules. An empty list means no
    /// substitution will occur.
    #[prost(message, repeated, tag = "8")]
    pub substitution_rules: ::prost::alloc::vec::Vec<restore_config::SubstitutionRule>,
    /// Specifies the namespaced resources to restore from the Backup.
    /// Only one of the entries may be specified. If not specified, NO namespaced
    /// resources will be restored.
    #[prost(oneof = "restore_config::NamespacedResourceRestoreScope", tags = "5, 6, 7")]
    pub namespaced_resource_restore_scope: ::core::option::Option<
        restore_config::NamespacedResourceRestoreScope,
    >,
}
/// Nested message and enum types in `RestoreConfig`.
pub mod restore_config {
    /// This is a direct map to the Kubernetes GroupKind type
    /// [GroupKind](<https://godoc.org/k8s.io/apimachinery/pkg/runtime/schema#GroupKind>)
    /// and is used for identifying specific "types" of resources to restore.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct GroupKind {
        /// API group string of a Kubernetes resource, e.g.
        /// "apiextensions.k8s.io", "storage.k8s.io", etc.
        /// Note: use empty string for core API group
        #[prost(string, tag = "1")]
        pub resource_group: ::prost::alloc::string::String,
        /// Kind of a Kubernetes resource, e.g.
        /// "CustomResourceDefinition", "StorageClass", etc.
        #[prost(string, tag = "2")]
        pub resource_kind: ::prost::alloc::string::String,
    }
    /// Identifies the cluster-scoped resources to restore from the Backup.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ClusterResourceRestoreScope {
        /// A list of "types" of cluster-scoped resources to be restored from the
        /// Backup.  An empty list means that NO cluster-scoped resources will be
        /// restored. Note that Namespaces and PersistentVolume restoration is
        /// handled separately and is not governed by this field.
        #[prost(message, repeated, tag = "1")]
        pub selected_group_kinds: ::prost::alloc::vec::Vec<GroupKind>,
    }
    /// A transformation rule to be applied against Kubernetes resources as they
    /// are selected for restoration from a Backup. A rule contains both filtering
    /// logic (which resources are subject to substitution) and substitution logic.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct SubstitutionRule {
        /// (Filtering parameter) Any resource subject to substitution must be
        /// contained within one of the listed Kubernetes Namespace in the Backup.
        /// If this field is not provided, no namespace filtering will be performed
        /// (all resources in all Namespaces, including all cluster-scoped resources,
        /// will be candidates for substitution).
        /// To mix cluster-scoped and namespaced resources in the same rule, use an
        /// empty string ("") as one of the target namespaces.
        #[prost(string, repeated, tag = "1")]
        pub target_namespaces: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
        /// (Filtering parameter) Any resource subject to substitution must belong to
        /// one of the listed "types".
        /// If this field is not provided, no type filtering will be performed (all
        /// resources of all types matching previous filtering parameters will be
        /// candidates for substitution).
        #[prost(message, repeated, tag = "2")]
        pub target_group_kinds: ::prost::alloc::vec::Vec<GroupKind>,
        /// This is a \[JSONPath\]
        /// ([<https://kubernetes.io/docs/reference/kubectl/jsonpath/>)
        /// expression that matches specific fields of candidate
        /// resources and it operates as both a filtering parameter (resources that
        /// are not matched with this expression will not be candidates for
        /// substitution) as well as a field identifier (identifies exactly which
        /// fields out of the candidate resources will be modified).
        #[prost(string, tag = "3")]
        pub target_json_path: ::prost::alloc::string::String,
        /// (Filtering parameter) This is a \[regular expression\]
        /// (<https://en.wikipedia.org/wiki/Regular_expression>)
        /// that is compared against the fields matched by the target_json_path
        /// expression (and must also have passed the previous filters).
        /// Substitution will not be performed against fields whose
        /// value does not match this expression. If this field is NOT specified,
        /// then ALL fields matched by the target_json_path expression will undergo
        /// substitution. Note that an empty (e.g., "", rather than unspecified)
        /// value for for this field will only match empty fields.
        #[prost(string, tag = "4")]
        pub original_value_pattern: ::prost::alloc::string::String,
        /// This is the new value to set for any fields that pass the filtering and
        /// selection criteria. To remove a value from a Kubernetes resource, either
        /// leave this field unspecified, or set it to the empty string ("").
        #[prost(string, tag = "5")]
        pub new_value: ::prost::alloc::string::String,
    }
    /// Defines how volume data should be restored
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum VolumeDataRestorePolicy {
        /// unspecified, default value
        Unspecified = 0,
        /// For each PVC to be restored, will create a new underlying volume (and PV)
        /// from the corresponding VolumeBackup contained within the Backup.
        RestoreVolumeDataFromBackup = 1,
        /// For each PVC to be restored, attempt to reuse the original PV contained
        /// in the Backup (with its original underlying volume).  Note that option
        /// is likely only usable when restoring a workload to its original cluster.
        ReuseVolumeHandleFromBackup = 2,
        /// For each PVC to be restored, PVCs will be created without any particular
        /// action to restore data.  In this case, the normal Kubernetes provisioning
        /// logic would kick in, and this would likely result in either dynamically
        /// provisioning blank PVs or binding to statically provisioned PVs.
        NoVolumeDataRestoration = 3,
    }
    impl VolumeDataRestorePolicy {
        /// 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 {
                VolumeDataRestorePolicy::Unspecified => {
                    "VOLUME_DATA_RESTORE_POLICY_UNSPECIFIED"
                }
                VolumeDataRestorePolicy::RestoreVolumeDataFromBackup => {
                    "RESTORE_VOLUME_DATA_FROM_BACKUP"
                }
                VolumeDataRestorePolicy::ReuseVolumeHandleFromBackup => {
                    "REUSE_VOLUME_HANDLE_FROM_BACKUP"
                }
                VolumeDataRestorePolicy::NoVolumeDataRestoration => {
                    "NO_VOLUME_DATA_RESTORATION"
                }
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "VOLUME_DATA_RESTORE_POLICY_UNSPECIFIED" => Some(Self::Unspecified),
                "RESTORE_VOLUME_DATA_FROM_BACKUP" => {
                    Some(Self::RestoreVolumeDataFromBackup)
                }
                "REUSE_VOLUME_HANDLE_FROM_BACKUP" => {
                    Some(Self::ReuseVolumeHandleFromBackup)
                }
                "NO_VOLUME_DATA_RESTORATION" => Some(Self::NoVolumeDataRestoration),
                _ => None,
            }
        }
    }
    /// Defines the behavior for handling the situation where cluster-scoped
    /// resources being restored already exist in the target cluster.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ClusterResourceConflictPolicy {
        /// Unspecified. Only allowed if no cluster-scoped resources will be
        /// restored.
        Unspecified = 0,
        /// Do not attempt to restore the conflicting resource.
        UseExistingVersion = 1,
        /// Delete the existing version before re-creating it from the Backup.
        /// Note that this is a dangerous option which could cause unintentional
        /// data loss if used inappropriately - for example, deleting a CRD will
        /// cause Kubernetes to delete all CRs of that type.
        UseBackupVersion = 2,
    }
    impl ClusterResourceConflictPolicy {
        /// 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 {
                ClusterResourceConflictPolicy::Unspecified => {
                    "CLUSTER_RESOURCE_CONFLICT_POLICY_UNSPECIFIED"
                }
                ClusterResourceConflictPolicy::UseExistingVersion => {
                    "USE_EXISTING_VERSION"
                }
                ClusterResourceConflictPolicy::UseBackupVersion => "USE_BACKUP_VERSION",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "CLUSTER_RESOURCE_CONFLICT_POLICY_UNSPECIFIED" => Some(Self::Unspecified),
                "USE_EXISTING_VERSION" => Some(Self::UseExistingVersion),
                "USE_BACKUP_VERSION" => Some(Self::UseBackupVersion),
                _ => None,
            }
        }
    }
    /// Defines the behavior for handling the situation where sets of namespaced
    /// resources being restored already exist in the target cluster.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum NamespacedResourceRestoreMode {
        /// Unspecified. Only allowed if no namespaced resources will be restored.
        Unspecified = 0,
        /// When conflicting top-level resources (either Namespaces or
        /// ProtectedApplications, depending upon the scope) are encountered, this
        /// will first trigger a delete of the conflicting resource AND ALL OF ITS
        /// REFERENCED RESOURCES (e.g., all resources in the Namespace or all
        /// resources referenced by the ProtectedApplication) before restoring the
        /// resources from the Backup. This mode should only be used when you are
        /// intending to revert some portion of a cluster to an earlier state.
        DeleteAndRestore = 1,
        /// If conflicting top-level resources (either Namespaces or
        /// ProtectedApplications, depending upon the scope) are encountered at the
        /// beginning of a restore process, the Restore will fail.  If a conflict
        /// occurs during the restore process itself (e.g., because an out of band
        /// process creates conflicting resources), a conflict will be reported.
        FailOnConflict = 2,
    }
    impl NamespacedResourceRestoreMode {
        /// 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 {
                NamespacedResourceRestoreMode::Unspecified => {
                    "NAMESPACED_RESOURCE_RESTORE_MODE_UNSPECIFIED"
                }
                NamespacedResourceRestoreMode::DeleteAndRestore => "DELETE_AND_RESTORE",
                NamespacedResourceRestoreMode::FailOnConflict => "FAIL_ON_CONFLICT",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "NAMESPACED_RESOURCE_RESTORE_MODE_UNSPECIFIED" => Some(Self::Unspecified),
                "DELETE_AND_RESTORE" => Some(Self::DeleteAndRestore),
                "FAIL_ON_CONFLICT" => Some(Self::FailOnConflict),
                _ => None,
            }
        }
    }
    /// Specifies the namespaced resources to restore from the Backup.
    /// Only one of the entries may be specified. If not specified, NO namespaced
    /// resources will be restored.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum NamespacedResourceRestoreScope {
        /// Restore all namespaced resources in the Backup if set to "True".
        /// Specifying this field to "False" is an error.
        #[prost(bool, tag = "5")]
        AllNamespaces(bool),
        /// A list of selected Namespaces to restore from the Backup. The listed
        /// Namespaces and all resources contained in them will be restored.
        #[prost(message, tag = "6")]
        SelectedNamespaces(super::Namespaces),
        /// A list of selected ProtectedApplications to restore. The listed
        /// ProtectedApplications and all the resources to which they refer will be
        /// restored.
        #[prost(message, tag = "7")]
        SelectedApplications(super::NamespacedNames),
    }
}
/// use case 1
/// A log entry when modification(creation, update, deletion) is made to a
/// BackupPlan
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BackupPlanChange {
    /// The full name of the old BackupPlan resource that is being modified.
    /// Empty for creation.
    /// Format: projects/{project}/locations/{location}/backupPlans/{backup_plan}
    #[prost(string, tag = "1")]
    pub backup_plan: ::prost::alloc::string::String,
    /// Type of the change is being made.
    #[prost(enumeration = "ChangeType", tag = "2")]
    pub change_type: i32,
    /// Modification details.
    #[prost(message, optional, tag = "3")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// The input BackupPlan resource with the updated fields populated to update
    /// the source BackupPlan to.
    #[prost(message, optional, tag = "4")]
    pub input_backup_plan: ::core::option::Option<LoggedBackupPlan>,
    /// The error code and message.
    #[prost(message, optional, tag = "5")]
    pub error: ::core::option::Option<super::super::super::super::rpc::Status>,
}
/// use case 2
/// A log entry when modification(creation, update, deletion) is made to a
/// Backup
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BackupChange {
    /// The full name of the Backup resource that is being modified.
    /// Format:
    /// projects/{project}/locations/{location}/backupPlans/{backup_plan}/backups/{backup}
    #[prost(string, tag = "1")]
    pub backup: ::prost::alloc::string::String,
    /// Type of the change is being made.
    #[prost(enumeration = "ChangeType", tag = "2")]
    pub change_type: i32,
    /// Whether the change is made manually or automatically.
    #[prost(bool, tag = "3")]
    pub scheduled: bool,
    /// Modification details.
    #[prost(message, optional, tag = "4")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// The input Backup resource with the updated fields populated to update
    /// the source Backup to, or the backup created automatically from retention
    /// policy.
    #[prost(message, optional, tag = "5")]
    pub input_backup: ::core::option::Option<LoggedBackup>,
    /// The error code and message.
    #[prost(message, optional, tag = "6")]
    pub error: ::core::option::Option<super::super::super::super::rpc::Status>,
}
/// use case 3
/// A log entry when modification(creation, update, deletion) is made to a
/// restorePlan.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RestorePlanChange {
    /// The full name of the RestorePlan resource that is being modified.
    /// Empty for creation.
    /// Format: projects/*/locations/*/restorePlans/*
    #[prost(string, tag = "1")]
    pub restore_plan: ::prost::alloc::string::String,
    /// Type of the change is being made.
    #[prost(enumeration = "ChangeType", tag = "2")]
    pub change_type: i32,
    /// Modification details.
    #[prost(message, optional, tag = "3")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// The input RestorePlan resource with the updated fields populated to update
    /// the source RestorePlan to.
    #[prost(message, optional, tag = "4")]
    pub input_restore_plan: ::core::option::Option<LoggedRestorePlan>,
    /// The error code and message.
    #[prost(message, optional, tag = "5")]
    pub error: ::core::option::Option<super::super::super::super::rpc::Status>,
}
/// use case 4
/// A log entry when modification(creation, update, deletion) is made to a
/// restore.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RestoreChange {
    /// The full name of the Restore resource that is being modified.
    /// Empty for creation.
    /// Format: projects/*/locations/*/restorePlans/*/restores/*
    #[prost(string, tag = "1")]
    pub restore: ::prost::alloc::string::String,
    /// Type of the change is being made.
    #[prost(enumeration = "ChangeType", tag = "2")]
    pub change_type: i32,
    /// Modification details.
    #[prost(message, optional, tag = "3")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// The input Restore resource with the updated fields populated to update
    /// the source Restore to.
    #[prost(message, optional, tag = "4")]
    pub input_restore: ::core::option::Option<LoggedRestore>,
    /// The error code and message.
    #[prost(message, optional, tag = "5")]
    pub error: ::core::option::Option<super::super::super::super::rpc::Status>,
}
/// The type of changes this log is about.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ChangeType {
    /// Default value, not specified.
    Unspecified = 0,
    /// The resource is created.
    Creation = 1,
    /// The resource is updated.
    Update = 2,
    /// The resource is deleted.
    Deletion = 3,
}
impl ChangeType {
    /// 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 {
            ChangeType::Unspecified => "CHANGE_TYPE_UNSPECIFIED",
            ChangeType::Creation => "CREATION",
            ChangeType::Update => "UPDATE",
            ChangeType::Deletion => "DELETION",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "CHANGE_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
            "CREATION" => Some(Self::Creation),
            "UPDATE" => Some(Self::Update),
            "DELETION" => Some(Self::Deletion),
            _ => None,
        }
    }
}
