google_cloud_redis_v1/

model.rs

// Copyright 2025 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Code generated by sidekick. DO NOT EDIT.

#![allow(rustdoc::redundant_explicit_links)]
#![allow(rustdoc::broken_intra_doc_links)]
#![no_implicit_prelude]
extern crate async_trait;
extern crate bytes;
extern crate gax;
extern crate gaxi;
extern crate gtype;
extern crate lazy_static;
extern crate location;
extern crate longrunning;
extern crate lro;
extern crate reqwest;
extern crate serde;
extern crate serde_json;
extern crate serde_with;
extern crate std;
extern crate tracing;
extern crate wkt;

mod debug;
mod deserialize;
mod serialize;

/// Node specific properties.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NodeInfo {
    /// Output only. Node identifying string. e.g. 'node-0', 'node-1'
    pub id: std::string::String,

    /// Output only. Location of the node.
    pub zone: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl NodeInfo {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [id][crate::model::NodeInfo::id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::NodeInfo;
    /// let x = NodeInfo::new().set_id("example");
    /// ```
    pub fn set_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.id = v.into();
        self
    }

    /// Sets the value of [zone][crate::model::NodeInfo::zone].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::NodeInfo;
    /// let x = NodeInfo::new().set_zone("example");
    /// ```
    pub fn set_zone<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.zone = v.into();
        self
    }
}

impl wkt::message::Message for NodeInfo {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.redis.v1.NodeInfo"
    }
}

/// A Memorystore for Redis instance.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Instance {
    /// Required. Unique name of the resource in this scope including project and
    /// location using the form:
    /// `projects/{project_id}/locations/{location_id}/instances/{instance_id}`
    ///
    /// Note: Redis instances are managed and addressed at regional level so
    /// location_id here refers to a GCP region; however, users may choose which
    /// specific zone (or collection of zones for cross-zone instances) an instance
    /// should be provisioned in. Refer to
    /// [location_id][google.cloud.redis.v1.Instance.location_id] and
    /// [alternative_location_id][google.cloud.redis.v1.Instance.alternative_location_id]
    /// fields for more details.
    ///
    /// [google.cloud.redis.v1.Instance.alternative_location_id]: crate::model::Instance::alternative_location_id
    /// [google.cloud.redis.v1.Instance.location_id]: crate::model::Instance::location_id
    pub name: std::string::String,

    /// An arbitrary and optional user-provided name for the instance.
    pub display_name: std::string::String,

    /// Resource labels to represent user provided metadata
    pub labels: std::collections::HashMap<std::string::String, std::string::String>,

    /// Optional. The zone where the instance will be provisioned. If not provided,
    /// the service will choose a zone from the specified region for the instance.
    /// For standard tier, additional nodes will be added across multiple zones for
    /// protection against zonal failures. If specified, at least one node will be
    /// provisioned in this zone.
    pub location_id: std::string::String,

    /// Optional. If specified, at least one node will be provisioned in this zone
    /// in addition to the zone specified in location_id. Only applicable to
    /// standard tier. If provided, it must be a different zone from the one
    /// provided in [location_id]. Additional nodes beyond the first 2 will be
    /// placed in zones selected by the service.
    pub alternative_location_id: std::string::String,

    /// Optional. The version of Redis software.
    /// If not provided, latest supported version will be used. Currently, the
    /// supported values are:
    ///
    /// * `REDIS_3_2` for Redis 3.2 compatibility
    /// * `REDIS_4_0` for Redis 4.0 compatibility (default)
    /// * `REDIS_5_0` for Redis 5.0 compatibility
    /// * `REDIS_6_X` for Redis 6.x compatibility
    pub redis_version: std::string::String,

    /// Optional. For DIRECT_PEERING mode, the CIDR range of internal addresses
    /// that are reserved for this instance. Range must
    /// be unique and non-overlapping with existing subnets in an authorized
    /// network. For PRIVATE_SERVICE_ACCESS mode, the name of one allocated IP
    /// address ranges associated with this private service access connection.
    /// If not provided, the service will choose an unused /29 block, for
    /// example, 10.0.0.0/29 or 192.168.0.0/29.  For READ_REPLICAS_ENABLED
    /// the default block size is /28.
    pub reserved_ip_range: std::string::String,

    /// Optional. Additional IP range for node placement. Required when enabling
    /// read replicas on an existing instance. For DIRECT_PEERING mode value must
    /// be a CIDR range of size /28, or "auto". For PRIVATE_SERVICE_ACCESS mode
    /// value must be the name of an allocated address range associated with the
    /// private service access connection, or "auto".
    pub secondary_ip_range: std::string::String,

    /// Output only. Hostname or IP address of the exposed Redis endpoint used by
    /// clients to connect to the service.
    pub host: std::string::String,

    /// Output only. The port number of the exposed Redis endpoint.
    pub port: i32,

    /// Output only. The current zone where the Redis primary node is located. In
    /// basic tier, this will always be the same as [location_id]. In
    /// standard tier, this can be the zone of any node in the instance.
    pub current_location_id: std::string::String,

    /// Output only. The time the instance was created.
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The current state of this instance.
    pub state: crate::model::instance::State,

    /// Output only. Additional information about the current status of this
    /// instance, if available.
    pub status_message: std::string::String,

    /// Optional. Redis configuration parameters, according to
    /// <http://redis.io/topics/config>. Currently, the only supported parameters
    /// are:
    ///
    /// Redis version 3.2 and newer:
    ///
    /// * maxmemory-policy
    /// * notify-keyspace-events
    ///
    /// Redis version 4.0 and newer:
    ///
    /// * activedefrag
    /// * lfu-decay-time
    /// * lfu-log-factor
    /// * maxmemory-gb
    ///
    /// Redis version 5.0 and newer:
    ///
    /// * stream-node-max-bytes
    /// * stream-node-max-entries
    pub redis_configs: std::collections::HashMap<std::string::String, std::string::String>,

    /// Required. The service tier of the instance.
    pub tier: crate::model::instance::Tier,

    /// Required. Redis memory size in GiB.
    pub memory_size_gb: i32,

    /// Optional. The full name of the Google Compute Engine
    /// [network](https://cloud.google.com/vpc/docs/vpc) to which the
    /// instance is connected. If left unspecified, the `default` network
    /// will be used.
    pub authorized_network: std::string::String,

    /// Output only. Cloud IAM identity used by import / export operations to
    /// transfer data to/from Cloud Storage. Format is
    /// "serviceAccount:<service_account_email>". The value may change over time
    /// for a given instance so should be checked before each import/export
    /// operation.
    pub persistence_iam_identity: std::string::String,

    /// Optional. The network connect mode of the Redis instance.
    /// If not provided, the connect mode defaults to DIRECT_PEERING.
    pub connect_mode: crate::model::instance::ConnectMode,

    /// Optional. Indicates whether OSS Redis AUTH is enabled for the instance. If
    /// set to "true" AUTH is enabled on the instance. Default value is "false"
    /// meaning AUTH is disabled.
    pub auth_enabled: bool,

    /// Output only. List of server CA certificates for the instance.
    pub server_ca_certs: std::vec::Vec<crate::model::TlsCertificate>,

    /// Optional. The TLS mode of the Redis instance.
    /// If not provided, TLS is disabled for the instance.
    pub transit_encryption_mode: crate::model::instance::TransitEncryptionMode,

    /// Optional. The maintenance policy for the instance. If not provided,
    /// maintenance events can be performed at any time.
    pub maintenance_policy: std::option::Option<crate::model::MaintenancePolicy>,

    /// Output only. Date and time of upcoming maintenance events which have been
    /// scheduled.
    pub maintenance_schedule: std::option::Option<crate::model::MaintenanceSchedule>,

    /// Optional. The number of replica nodes. The valid range for the Standard
    /// Tier with read replicas enabled is [1-5] and defaults to 2. If read
    /// replicas are not enabled for a Standard Tier instance, the only valid value
    /// is 1 and the default is 1. The valid value for basic tier is 0 and the
    /// default is also 0.
    pub replica_count: i32,

    /// Output only. Info per node.
    pub nodes: std::vec::Vec<crate::model::NodeInfo>,

    /// Output only. Hostname or IP address of the exposed readonly Redis
    /// endpoint. Standard tier only. Targets all healthy replica nodes in
    /// instance. Replication is asynchronous and replica nodes will exhibit some
    /// lag behind the primary. Write requests must target 'host'.
    pub read_endpoint: std::string::String,

    /// Output only. The port number of the exposed readonly redis
    /// endpoint. Standard tier only. Write requests should target 'port'.
    pub read_endpoint_port: i32,

    /// Optional. Read replicas mode for the instance. Defaults to
    /// READ_REPLICAS_DISABLED.
    pub read_replicas_mode: crate::model::instance::ReadReplicasMode,

    /// Optional. The KMS key reference that the customer provides when trying to
    /// create the instance.
    pub customer_managed_key: std::string::String,

    /// Optional. Persistence configuration parameters
    pub persistence_config: std::option::Option<crate::model::PersistenceConfig>,

    /// Optional. reasons that causes instance in "SUSPENDED" state.
    pub suspension_reasons: std::vec::Vec<crate::model::instance::SuspensionReason>,

    /// Optional. The self service update maintenance version.
    /// The version is date based such as "20210712_00_00".
    pub maintenance_version: std::string::String,

    /// Optional. The available maintenance versions that an instance could update
    /// to.
    pub available_maintenance_versions: std::vec::Vec<std::string::String>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl Instance {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::Instance::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// let x = Instance::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [display_name][crate::model::Instance::display_name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// let x = Instance::new().set_display_name("example");
    /// ```
    pub fn set_display_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.display_name = v.into();
        self
    }

    /// Sets the value of [labels][crate::model::Instance::labels].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// let x = Instance::new().set_labels([
    ///     ("key0", "abc"),
    ///     ("key1", "xyz"),
    /// ]);
    /// ```
    pub fn set_labels<T, K, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = (K, V)>,
        K: std::convert::Into<std::string::String>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.labels = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }

    /// Sets the value of [location_id][crate::model::Instance::location_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// let x = Instance::new().set_location_id("example");
    /// ```
    pub fn set_location_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.location_id = v.into();
        self
    }

    /// Sets the value of [alternative_location_id][crate::model::Instance::alternative_location_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// let x = Instance::new().set_alternative_location_id("example");
    /// ```
    pub fn set_alternative_location_id<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.alternative_location_id = v.into();
        self
    }

    /// Sets the value of [redis_version][crate::model::Instance::redis_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// let x = Instance::new().set_redis_version("example");
    /// ```
    pub fn set_redis_version<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.redis_version = v.into();
        self
    }

    /// Sets the value of [reserved_ip_range][crate::model::Instance::reserved_ip_range].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// let x = Instance::new().set_reserved_ip_range("example");
    /// ```
    pub fn set_reserved_ip_range<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.reserved_ip_range = v.into();
        self
    }

    /// Sets the value of [secondary_ip_range][crate::model::Instance::secondary_ip_range].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// let x = Instance::new().set_secondary_ip_range("example");
    /// ```
    pub fn set_secondary_ip_range<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.secondary_ip_range = v.into();
        self
    }

    /// Sets the value of [host][crate::model::Instance::host].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// let x = Instance::new().set_host("example");
    /// ```
    pub fn set_host<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.host = v.into();
        self
    }

    /// Sets the value of [port][crate::model::Instance::port].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// let x = Instance::new().set_port(42);
    /// ```
    pub fn set_port<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.port = v.into();
        self
    }

    /// Sets the value of [current_location_id][crate::model::Instance::current_location_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// let x = Instance::new().set_current_location_id("example");
    /// ```
    pub fn set_current_location_id<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.current_location_id = v.into();
        self
    }

    /// Sets the value of [create_time][crate::model::Instance::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// use wkt::Timestamp;
    /// let x = Instance::new().set_create_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_create_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.create_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [create_time][crate::model::Instance::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// use wkt::Timestamp;
    /// let x = Instance::new().set_or_clear_create_time(Some(Timestamp::default()/* use setters */));
    /// let x = Instance::new().set_or_clear_create_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_create_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.create_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [state][crate::model::Instance::state].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// use google_cloud_redis_v1::model::instance::State;
    /// let x0 = Instance::new().set_state(State::Creating);
    /// let x1 = Instance::new().set_state(State::Ready);
    /// let x2 = Instance::new().set_state(State::Updating);
    /// ```
    pub fn set_state<T: std::convert::Into<crate::model::instance::State>>(mut self, v: T) -> Self {
        self.state = v.into();
        self
    }

    /// Sets the value of [status_message][crate::model::Instance::status_message].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// let x = Instance::new().set_status_message("example");
    /// ```
    pub fn set_status_message<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.status_message = v.into();
        self
    }

    /// Sets the value of [redis_configs][crate::model::Instance::redis_configs].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// let x = Instance::new().set_redis_configs([
    ///     ("key0", "abc"),
    ///     ("key1", "xyz"),
    /// ]);
    /// ```
    pub fn set_redis_configs<T, K, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = (K, V)>,
        K: std::convert::Into<std::string::String>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.redis_configs = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }

    /// Sets the value of [tier][crate::model::Instance::tier].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// use google_cloud_redis_v1::model::instance::Tier;
    /// let x0 = Instance::new().set_tier(Tier::Basic);
    /// let x1 = Instance::new().set_tier(Tier::StandardHa);
    /// ```
    pub fn set_tier<T: std::convert::Into<crate::model::instance::Tier>>(mut self, v: T) -> Self {
        self.tier = v.into();
        self
    }

    /// Sets the value of [memory_size_gb][crate::model::Instance::memory_size_gb].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// let x = Instance::new().set_memory_size_gb(42);
    /// ```
    pub fn set_memory_size_gb<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.memory_size_gb = v.into();
        self
    }

    /// Sets the value of [authorized_network][crate::model::Instance::authorized_network].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// let x = Instance::new().set_authorized_network("example");
    /// ```
    pub fn set_authorized_network<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.authorized_network = v.into();
        self
    }

    /// Sets the value of [persistence_iam_identity][crate::model::Instance::persistence_iam_identity].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// let x = Instance::new().set_persistence_iam_identity("example");
    /// ```
    pub fn set_persistence_iam_identity<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.persistence_iam_identity = v.into();
        self
    }

    /// Sets the value of [connect_mode][crate::model::Instance::connect_mode].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// use google_cloud_redis_v1::model::instance::ConnectMode;
    /// let x0 = Instance::new().set_connect_mode(ConnectMode::DirectPeering);
    /// let x1 = Instance::new().set_connect_mode(ConnectMode::PrivateServiceAccess);
    /// ```
    pub fn set_connect_mode<T: std::convert::Into<crate::model::instance::ConnectMode>>(
        mut self,
        v: T,
    ) -> Self {
        self.connect_mode = v.into();
        self
    }

    /// Sets the value of [auth_enabled][crate::model::Instance::auth_enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// let x = Instance::new().set_auth_enabled(true);
    /// ```
    pub fn set_auth_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.auth_enabled = v.into();
        self
    }

    /// Sets the value of [server_ca_certs][crate::model::Instance::server_ca_certs].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// use google_cloud_redis_v1::model::TlsCertificate;
    /// let x = Instance::new()
    ///     .set_server_ca_certs([
    ///         TlsCertificate::default()/* use setters */,
    ///         TlsCertificate::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_server_ca_certs<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::TlsCertificate>,
    {
        use std::iter::Iterator;
        self.server_ca_certs = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [transit_encryption_mode][crate::model::Instance::transit_encryption_mode].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// use google_cloud_redis_v1::model::instance::TransitEncryptionMode;
    /// let x0 = Instance::new().set_transit_encryption_mode(TransitEncryptionMode::ServerAuthentication);
    /// let x1 = Instance::new().set_transit_encryption_mode(TransitEncryptionMode::Disabled);
    /// ```
    pub fn set_transit_encryption_mode<
        T: std::convert::Into<crate::model::instance::TransitEncryptionMode>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.transit_encryption_mode = v.into();
        self
    }

    /// Sets the value of [maintenance_policy][crate::model::Instance::maintenance_policy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// use google_cloud_redis_v1::model::MaintenancePolicy;
    /// let x = Instance::new().set_maintenance_policy(MaintenancePolicy::default()/* use setters */);
    /// ```
    pub fn set_maintenance_policy<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::MaintenancePolicy>,
    {
        self.maintenance_policy = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [maintenance_policy][crate::model::Instance::maintenance_policy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// use google_cloud_redis_v1::model::MaintenancePolicy;
    /// let x = Instance::new().set_or_clear_maintenance_policy(Some(MaintenancePolicy::default()/* use setters */));
    /// let x = Instance::new().set_or_clear_maintenance_policy(None::<MaintenancePolicy>);
    /// ```
    pub fn set_or_clear_maintenance_policy<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::MaintenancePolicy>,
    {
        self.maintenance_policy = v.map(|x| x.into());
        self
    }

    /// Sets the value of [maintenance_schedule][crate::model::Instance::maintenance_schedule].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// use google_cloud_redis_v1::model::MaintenanceSchedule;
    /// let x = Instance::new().set_maintenance_schedule(MaintenanceSchedule::default()/* use setters */);
    /// ```
    pub fn set_maintenance_schedule<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::MaintenanceSchedule>,
    {
        self.maintenance_schedule = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [maintenance_schedule][crate::model::Instance::maintenance_schedule].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// use google_cloud_redis_v1::model::MaintenanceSchedule;
    /// let x = Instance::new().set_or_clear_maintenance_schedule(Some(MaintenanceSchedule::default()/* use setters */));
    /// let x = Instance::new().set_or_clear_maintenance_schedule(None::<MaintenanceSchedule>);
    /// ```
    pub fn set_or_clear_maintenance_schedule<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::MaintenanceSchedule>,
    {
        self.maintenance_schedule = v.map(|x| x.into());
        self
    }

    /// Sets the value of [replica_count][crate::model::Instance::replica_count].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// let x = Instance::new().set_replica_count(42);
    /// ```
    pub fn set_replica_count<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.replica_count = v.into();
        self
    }

    /// Sets the value of [nodes][crate::model::Instance::nodes].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// use google_cloud_redis_v1::model::NodeInfo;
    /// let x = Instance::new()
    ///     .set_nodes([
    ///         NodeInfo::default()/* use setters */,
    ///         NodeInfo::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_nodes<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::NodeInfo>,
    {
        use std::iter::Iterator;
        self.nodes = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [read_endpoint][crate::model::Instance::read_endpoint].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// let x = Instance::new().set_read_endpoint("example");
    /// ```
    pub fn set_read_endpoint<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.read_endpoint = v.into();
        self
    }

    /// Sets the value of [read_endpoint_port][crate::model::Instance::read_endpoint_port].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// let x = Instance::new().set_read_endpoint_port(42);
    /// ```
    pub fn set_read_endpoint_port<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.read_endpoint_port = v.into();
        self
    }

    /// Sets the value of [read_replicas_mode][crate::model::Instance::read_replicas_mode].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// use google_cloud_redis_v1::model::instance::ReadReplicasMode;
    /// let x0 = Instance::new().set_read_replicas_mode(ReadReplicasMode::ReadReplicasDisabled);
    /// let x1 = Instance::new().set_read_replicas_mode(ReadReplicasMode::ReadReplicasEnabled);
    /// ```
    pub fn set_read_replicas_mode<
        T: std::convert::Into<crate::model::instance::ReadReplicasMode>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.read_replicas_mode = v.into();
        self
    }

    /// Sets the value of [customer_managed_key][crate::model::Instance::customer_managed_key].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// let x = Instance::new().set_customer_managed_key("example");
    /// ```
    pub fn set_customer_managed_key<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.customer_managed_key = v.into();
        self
    }

    /// Sets the value of [persistence_config][crate::model::Instance::persistence_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// use google_cloud_redis_v1::model::PersistenceConfig;
    /// let x = Instance::new().set_persistence_config(PersistenceConfig::default()/* use setters */);
    /// ```
    pub fn set_persistence_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::PersistenceConfig>,
    {
        self.persistence_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [persistence_config][crate::model::Instance::persistence_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// use google_cloud_redis_v1::model::PersistenceConfig;
    /// let x = Instance::new().set_or_clear_persistence_config(Some(PersistenceConfig::default()/* use setters */));
    /// let x = Instance::new().set_or_clear_persistence_config(None::<PersistenceConfig>);
    /// ```
    pub fn set_or_clear_persistence_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::PersistenceConfig>,
    {
        self.persistence_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [suspension_reasons][crate::model::Instance::suspension_reasons].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// use google_cloud_redis_v1::model::instance::SuspensionReason;
    /// let x = Instance::new().set_suspension_reasons([
    ///     SuspensionReason::CustomerManagedKeyIssue,
    /// ]);
    /// ```
    pub fn set_suspension_reasons<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::instance::SuspensionReason>,
    {
        use std::iter::Iterator;
        self.suspension_reasons = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [maintenance_version][crate::model::Instance::maintenance_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// let x = Instance::new().set_maintenance_version("example");
    /// ```
    pub fn set_maintenance_version<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.maintenance_version = v.into();
        self
    }

    /// Sets the value of [available_maintenance_versions][crate::model::Instance::available_maintenance_versions].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::Instance;
    /// let x = Instance::new().set_available_maintenance_versions(["a", "b", "c"]);
    /// ```
    pub fn set_available_maintenance_versions<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.available_maintenance_versions = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for Instance {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.redis.v1.Instance"
    }
}

/// Defines additional types related to [Instance].
pub mod instance {
    #[allow(unused_imports)]
    use super::*;

    /// Represents the different states of a Redis instance.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum State {
        /// Not set.
        Unspecified,
        /// Redis instance is being created.
        Creating,
        /// Redis instance has been created and is fully usable.
        Ready,
        /// Redis instance configuration is being updated. Certain kinds of updates
        /// may cause the instance to become unusable while the update is in
        /// progress.
        Updating,
        /// Redis instance is being deleted.
        Deleting,
        /// Redis instance is being repaired and may be unusable.
        Repairing,
        /// Maintenance is being performed on this Redis instance.
        Maintenance,
        /// Redis instance is importing data (availability may be affected).
        Importing,
        /// Redis instance is failing over (availability may be affected).
        FailingOver,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [State::value] or
        /// [State::name].
        UnknownValue(state::UnknownValue),
    }

    #[doc(hidden)]
    pub mod state {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl State {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Creating => std::option::Option::Some(1),
                Self::Ready => std::option::Option::Some(2),
                Self::Updating => std::option::Option::Some(3),
                Self::Deleting => std::option::Option::Some(4),
                Self::Repairing => std::option::Option::Some(5),
                Self::Maintenance => std::option::Option::Some(6),
                Self::Importing => std::option::Option::Some(8),
                Self::FailingOver => std::option::Option::Some(9),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("STATE_UNSPECIFIED"),
                Self::Creating => std::option::Option::Some("CREATING"),
                Self::Ready => std::option::Option::Some("READY"),
                Self::Updating => std::option::Option::Some("UPDATING"),
                Self::Deleting => std::option::Option::Some("DELETING"),
                Self::Repairing => std::option::Option::Some("REPAIRING"),
                Self::Maintenance => std::option::Option::Some("MAINTENANCE"),
                Self::Importing => std::option::Option::Some("IMPORTING"),
                Self::FailingOver => std::option::Option::Some("FAILING_OVER"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for State {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for State {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for State {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Creating,
                2 => Self::Ready,
                3 => Self::Updating,
                4 => Self::Deleting,
                5 => Self::Repairing,
                6 => Self::Maintenance,
                8 => Self::Importing,
                9 => Self::FailingOver,
                _ => Self::UnknownValue(state::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for State {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "STATE_UNSPECIFIED" => Self::Unspecified,
                "CREATING" => Self::Creating,
                "READY" => Self::Ready,
                "UPDATING" => Self::Updating,
                "DELETING" => Self::Deleting,
                "REPAIRING" => Self::Repairing,
                "MAINTENANCE" => Self::Maintenance,
                "IMPORTING" => Self::Importing,
                "FAILING_OVER" => Self::FailingOver,
                _ => Self::UnknownValue(state::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for State {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Creating => serializer.serialize_i32(1),
                Self::Ready => serializer.serialize_i32(2),
                Self::Updating => serializer.serialize_i32(3),
                Self::Deleting => serializer.serialize_i32(4),
                Self::Repairing => serializer.serialize_i32(5),
                Self::Maintenance => serializer.serialize_i32(6),
                Self::Importing => serializer.serialize_i32(8),
                Self::FailingOver => serializer.serialize_i32(9),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for State {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<State>::new(
                ".google.cloud.redis.v1.Instance.State",
            ))
        }
    }

    /// Available service tiers to choose from
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Tier {
        /// Not set.
        Unspecified,
        /// BASIC tier: standalone instance
        Basic,
        /// STANDARD_HA tier: highly available primary/replica instances
        StandardHa,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Tier::value] or
        /// [Tier::name].
        UnknownValue(tier::UnknownValue),
    }

    #[doc(hidden)]
    pub mod tier {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Tier {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Basic => std::option::Option::Some(1),
                Self::StandardHa => std::option::Option::Some(3),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("TIER_UNSPECIFIED"),
                Self::Basic => std::option::Option::Some("BASIC"),
                Self::StandardHa => std::option::Option::Some("STANDARD_HA"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Tier {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Tier {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Tier {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Basic,
                3 => Self::StandardHa,
                _ => Self::UnknownValue(tier::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Tier {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "TIER_UNSPECIFIED" => Self::Unspecified,
                "BASIC" => Self::Basic,
                "STANDARD_HA" => Self::StandardHa,
                _ => Self::UnknownValue(tier::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Tier {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Basic => serializer.serialize_i32(1),
                Self::StandardHa => serializer.serialize_i32(3),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Tier {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Tier>::new(
                ".google.cloud.redis.v1.Instance.Tier",
            ))
        }
    }

    /// Available connection modes.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum ConnectMode {
        /// Not set.
        Unspecified,
        /// Connect via direct peering to the Memorystore for Redis hosted service.
        DirectPeering,
        /// Connect your Memorystore for Redis instance using Private Service
        /// Access. Private services access provides an IP address range for multiple
        /// Google Cloud services, including Memorystore.
        PrivateServiceAccess,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [ConnectMode::value] or
        /// [ConnectMode::name].
        UnknownValue(connect_mode::UnknownValue),
    }

    #[doc(hidden)]
    pub mod connect_mode {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl ConnectMode {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::DirectPeering => std::option::Option::Some(1),
                Self::PrivateServiceAccess => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("CONNECT_MODE_UNSPECIFIED"),
                Self::DirectPeering => std::option::Option::Some("DIRECT_PEERING"),
                Self::PrivateServiceAccess => std::option::Option::Some("PRIVATE_SERVICE_ACCESS"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for ConnectMode {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for ConnectMode {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for ConnectMode {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::DirectPeering,
                2 => Self::PrivateServiceAccess,
                _ => Self::UnknownValue(connect_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for ConnectMode {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "CONNECT_MODE_UNSPECIFIED" => Self::Unspecified,
                "DIRECT_PEERING" => Self::DirectPeering,
                "PRIVATE_SERVICE_ACCESS" => Self::PrivateServiceAccess,
                _ => Self::UnknownValue(connect_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for ConnectMode {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::DirectPeering => serializer.serialize_i32(1),
                Self::PrivateServiceAccess => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for ConnectMode {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<ConnectMode>::new(
                ".google.cloud.redis.v1.Instance.ConnectMode",
            ))
        }
    }

    /// Available TLS modes.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum TransitEncryptionMode {
        /// Not set.
        Unspecified,
        /// Client to Server traffic encryption enabled with server authentication.
        ServerAuthentication,
        /// TLS is disabled for the instance.
        Disabled,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [TransitEncryptionMode::value] or
        /// [TransitEncryptionMode::name].
        UnknownValue(transit_encryption_mode::UnknownValue),
    }

    #[doc(hidden)]
    pub mod transit_encryption_mode {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl TransitEncryptionMode {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::ServerAuthentication => std::option::Option::Some(1),
                Self::Disabled => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => {
                    std::option::Option::Some("TRANSIT_ENCRYPTION_MODE_UNSPECIFIED")
                }
                Self::ServerAuthentication => std::option::Option::Some("SERVER_AUTHENTICATION"),
                Self::Disabled => std::option::Option::Some("DISABLED"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for TransitEncryptionMode {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for TransitEncryptionMode {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for TransitEncryptionMode {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::ServerAuthentication,
                2 => Self::Disabled,
                _ => Self::UnknownValue(transit_encryption_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for TransitEncryptionMode {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "TRANSIT_ENCRYPTION_MODE_UNSPECIFIED" => Self::Unspecified,
                "SERVER_AUTHENTICATION" => Self::ServerAuthentication,
                "DISABLED" => Self::Disabled,
                _ => Self::UnknownValue(transit_encryption_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for TransitEncryptionMode {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::ServerAuthentication => serializer.serialize_i32(1),
                Self::Disabled => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for TransitEncryptionMode {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<TransitEncryptionMode>::new(
                ".google.cloud.redis.v1.Instance.TransitEncryptionMode",
            ))
        }
    }

    /// Read replicas mode.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum ReadReplicasMode {
        /// If not set, Memorystore Redis backend will default to
        /// READ_REPLICAS_DISABLED.
        Unspecified,
        /// If disabled, read endpoint will not be provided and the instance cannot
        /// scale up or down the number of replicas.
        ReadReplicasDisabled,
        /// If enabled, read endpoint will be provided and the instance can scale
        /// up and down the number of replicas. Not valid for basic tier.
        ReadReplicasEnabled,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [ReadReplicasMode::value] or
        /// [ReadReplicasMode::name].
        UnknownValue(read_replicas_mode::UnknownValue),
    }

    #[doc(hidden)]
    pub mod read_replicas_mode {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl ReadReplicasMode {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::ReadReplicasDisabled => std::option::Option::Some(1),
                Self::ReadReplicasEnabled => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("READ_REPLICAS_MODE_UNSPECIFIED"),
                Self::ReadReplicasDisabled => std::option::Option::Some("READ_REPLICAS_DISABLED"),
                Self::ReadReplicasEnabled => std::option::Option::Some("READ_REPLICAS_ENABLED"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for ReadReplicasMode {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for ReadReplicasMode {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for ReadReplicasMode {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::ReadReplicasDisabled,
                2 => Self::ReadReplicasEnabled,
                _ => Self::UnknownValue(read_replicas_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for ReadReplicasMode {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "READ_REPLICAS_MODE_UNSPECIFIED" => Self::Unspecified,
                "READ_REPLICAS_DISABLED" => Self::ReadReplicasDisabled,
                "READ_REPLICAS_ENABLED" => Self::ReadReplicasEnabled,
                _ => Self::UnknownValue(read_replicas_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for ReadReplicasMode {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::ReadReplicasDisabled => serializer.serialize_i32(1),
                Self::ReadReplicasEnabled => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for ReadReplicasMode {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<ReadReplicasMode>::new(
                ".google.cloud.redis.v1.Instance.ReadReplicasMode",
            ))
        }
    }

    /// Possible reasons for the instance to be in a "SUSPENDED" state.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum SuspensionReason {
        /// Not set.
        Unspecified,
        /// Something wrong with the CMEK key provided by customer.
        CustomerManagedKeyIssue,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [SuspensionReason::value] or
        /// [SuspensionReason::name].
        UnknownValue(suspension_reason::UnknownValue),
    }

    #[doc(hidden)]
    pub mod suspension_reason {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl SuspensionReason {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::CustomerManagedKeyIssue => std::option::Option::Some(1),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("SUSPENSION_REASON_UNSPECIFIED"),
                Self::CustomerManagedKeyIssue => {
                    std::option::Option::Some("CUSTOMER_MANAGED_KEY_ISSUE")
                }
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for SuspensionReason {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for SuspensionReason {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for SuspensionReason {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::CustomerManagedKeyIssue,
                _ => Self::UnknownValue(suspension_reason::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for SuspensionReason {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "SUSPENSION_REASON_UNSPECIFIED" => Self::Unspecified,
                "CUSTOMER_MANAGED_KEY_ISSUE" => Self::CustomerManagedKeyIssue,
                _ => Self::UnknownValue(suspension_reason::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for SuspensionReason {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::CustomerManagedKeyIssue => serializer.serialize_i32(1),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for SuspensionReason {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<SuspensionReason>::new(
                ".google.cloud.redis.v1.Instance.SuspensionReason",
            ))
        }
    }
}

/// Configuration of the persistence functionality.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct PersistenceConfig {
    /// Optional. Controls whether Persistence features are enabled.
    /// If not provided, the existing value will be used.
    pub persistence_mode: crate::model::persistence_config::PersistenceMode,

    /// Optional. Period between RDB snapshots. Snapshots will be attempted every
    /// period starting from the provided snapshot start time. For example, a start
    /// time of 01/01/2033 06:45 and SIX_HOURS snapshot period will do nothing
    /// until 01/01/2033, and then trigger snapshots every day at 06:45, 12:45,
    /// 18:45, and 00:45 the next day, and so on. If not provided,
    /// TWENTY_FOUR_HOURS will be used as default.
    pub rdb_snapshot_period: crate::model::persistence_config::SnapshotPeriod,

    /// Output only. The next time that a snapshot attempt is scheduled to occur.
    pub rdb_next_snapshot_time: std::option::Option<wkt::Timestamp>,

    /// Optional. Date and time that the first snapshot was/will be attempted, and
    /// to which future snapshots will be aligned. If not provided, the current
    /// time will be used.
    pub rdb_snapshot_start_time: std::option::Option<wkt::Timestamp>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl PersistenceConfig {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [persistence_mode][crate::model::PersistenceConfig::persistence_mode].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::PersistenceConfig;
    /// use google_cloud_redis_v1::model::persistence_config::PersistenceMode;
    /// let x0 = PersistenceConfig::new().set_persistence_mode(PersistenceMode::Disabled);
    /// let x1 = PersistenceConfig::new().set_persistence_mode(PersistenceMode::Rdb);
    /// ```
    pub fn set_persistence_mode<
        T: std::convert::Into<crate::model::persistence_config::PersistenceMode>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.persistence_mode = v.into();
        self
    }

    /// Sets the value of [rdb_snapshot_period][crate::model::PersistenceConfig::rdb_snapshot_period].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::PersistenceConfig;
    /// use google_cloud_redis_v1::model::persistence_config::SnapshotPeriod;
    /// let x0 = PersistenceConfig::new().set_rdb_snapshot_period(SnapshotPeriod::OneHour);
    /// let x1 = PersistenceConfig::new().set_rdb_snapshot_period(SnapshotPeriod::SixHours);
    /// let x2 = PersistenceConfig::new().set_rdb_snapshot_period(SnapshotPeriod::TwelveHours);
    /// ```
    pub fn set_rdb_snapshot_period<
        T: std::convert::Into<crate::model::persistence_config::SnapshotPeriod>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.rdb_snapshot_period = v.into();
        self
    }

    /// Sets the value of [rdb_next_snapshot_time][crate::model::PersistenceConfig::rdb_next_snapshot_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::PersistenceConfig;
    /// use wkt::Timestamp;
    /// let x = PersistenceConfig::new().set_rdb_next_snapshot_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_rdb_next_snapshot_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.rdb_next_snapshot_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [rdb_next_snapshot_time][crate::model::PersistenceConfig::rdb_next_snapshot_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::PersistenceConfig;
    /// use wkt::Timestamp;
    /// let x = PersistenceConfig::new().set_or_clear_rdb_next_snapshot_time(Some(Timestamp::default()/* use setters */));
    /// let x = PersistenceConfig::new().set_or_clear_rdb_next_snapshot_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_rdb_next_snapshot_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.rdb_next_snapshot_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [rdb_snapshot_start_time][crate::model::PersistenceConfig::rdb_snapshot_start_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::PersistenceConfig;
    /// use wkt::Timestamp;
    /// let x = PersistenceConfig::new().set_rdb_snapshot_start_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_rdb_snapshot_start_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.rdb_snapshot_start_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [rdb_snapshot_start_time][crate::model::PersistenceConfig::rdb_snapshot_start_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::PersistenceConfig;
    /// use wkt::Timestamp;
    /// let x = PersistenceConfig::new().set_or_clear_rdb_snapshot_start_time(Some(Timestamp::default()/* use setters */));
    /// let x = PersistenceConfig::new().set_or_clear_rdb_snapshot_start_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_rdb_snapshot_start_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.rdb_snapshot_start_time = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for PersistenceConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.redis.v1.PersistenceConfig"
    }
}

/// Defines additional types related to [PersistenceConfig].
pub mod persistence_config {
    #[allow(unused_imports)]
    use super::*;

    /// Available Persistence modes.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum PersistenceMode {
        /// Not set.
        Unspecified,
        /// Persistence is disabled for the instance,
        /// and any existing snapshots are deleted.
        Disabled,
        /// RDB based Persistence is enabled.
        Rdb,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [PersistenceMode::value] or
        /// [PersistenceMode::name].
        UnknownValue(persistence_mode::UnknownValue),
    }

    #[doc(hidden)]
    pub mod persistence_mode {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl PersistenceMode {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Disabled => std::option::Option::Some(1),
                Self::Rdb => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("PERSISTENCE_MODE_UNSPECIFIED"),
                Self::Disabled => std::option::Option::Some("DISABLED"),
                Self::Rdb => std::option::Option::Some("RDB"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for PersistenceMode {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for PersistenceMode {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for PersistenceMode {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Disabled,
                2 => Self::Rdb,
                _ => Self::UnknownValue(persistence_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for PersistenceMode {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "PERSISTENCE_MODE_UNSPECIFIED" => Self::Unspecified,
                "DISABLED" => Self::Disabled,
                "RDB" => Self::Rdb,
                _ => Self::UnknownValue(persistence_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for PersistenceMode {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Disabled => serializer.serialize_i32(1),
                Self::Rdb => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for PersistenceMode {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<PersistenceMode>::new(
                ".google.cloud.redis.v1.PersistenceConfig.PersistenceMode",
            ))
        }
    }

    /// Available snapshot periods for scheduling.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum SnapshotPeriod {
        /// Not set.
        Unspecified,
        /// Snapshot every 1 hour.
        OneHour,
        /// Snapshot every 6 hours.
        SixHours,
        /// Snapshot every 12 hours.
        TwelveHours,
        /// Snapshot every 24 hours.
        TwentyFourHours,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [SnapshotPeriod::value] or
        /// [SnapshotPeriod::name].
        UnknownValue(snapshot_period::UnknownValue),
    }

    #[doc(hidden)]
    pub mod snapshot_period {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl SnapshotPeriod {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::OneHour => std::option::Option::Some(3),
                Self::SixHours => std::option::Option::Some(4),
                Self::TwelveHours => std::option::Option::Some(5),
                Self::TwentyFourHours => std::option::Option::Some(6),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("SNAPSHOT_PERIOD_UNSPECIFIED"),
                Self::OneHour => std::option::Option::Some("ONE_HOUR"),
                Self::SixHours => std::option::Option::Some("SIX_HOURS"),
                Self::TwelveHours => std::option::Option::Some("TWELVE_HOURS"),
                Self::TwentyFourHours => std::option::Option::Some("TWENTY_FOUR_HOURS"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for SnapshotPeriod {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for SnapshotPeriod {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for SnapshotPeriod {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                3 => Self::OneHour,
                4 => Self::SixHours,
                5 => Self::TwelveHours,
                6 => Self::TwentyFourHours,
                _ => Self::UnknownValue(snapshot_period::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for SnapshotPeriod {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "SNAPSHOT_PERIOD_UNSPECIFIED" => Self::Unspecified,
                "ONE_HOUR" => Self::OneHour,
                "SIX_HOURS" => Self::SixHours,
                "TWELVE_HOURS" => Self::TwelveHours,
                "TWENTY_FOUR_HOURS" => Self::TwentyFourHours,
                _ => Self::UnknownValue(snapshot_period::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for SnapshotPeriod {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::OneHour => serializer.serialize_i32(3),
                Self::SixHours => serializer.serialize_i32(4),
                Self::TwelveHours => serializer.serialize_i32(5),
                Self::TwentyFourHours => serializer.serialize_i32(6),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for SnapshotPeriod {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<SnapshotPeriod>::new(
                ".google.cloud.redis.v1.PersistenceConfig.SnapshotPeriod",
            ))
        }
    }
}

/// Request for
/// [RescheduleMaintenance][google.cloud.redis.v1.CloudRedis.RescheduleMaintenance].
///
/// [google.cloud.redis.v1.CloudRedis.RescheduleMaintenance]: crate::client::CloudRedis::reschedule_maintenance
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct RescheduleMaintenanceRequest {
    /// Required. Redis instance resource name using the form:
    /// `projects/{project_id}/locations/{location_id}/instances/{instance_id}`
    /// where `location_id` refers to a GCP region.
    pub name: std::string::String,

    /// Required. If reschedule type is SPECIFIC_TIME, must set up schedule_time as
    /// well.
    pub reschedule_type: crate::model::reschedule_maintenance_request::RescheduleType,

    /// Optional. Timestamp when the maintenance shall be rescheduled to if
    /// reschedule_type=SPECIFIC_TIME, in RFC 3339 format, for
    /// example `2012-11-15T16:19:00.094Z`.
    pub schedule_time: std::option::Option<wkt::Timestamp>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl RescheduleMaintenanceRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::RescheduleMaintenanceRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::RescheduleMaintenanceRequest;
    /// let x = RescheduleMaintenanceRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [reschedule_type][crate::model::RescheduleMaintenanceRequest::reschedule_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::RescheduleMaintenanceRequest;
    /// use google_cloud_redis_v1::model::reschedule_maintenance_request::RescheduleType;
    /// let x0 = RescheduleMaintenanceRequest::new().set_reschedule_type(RescheduleType::Immediate);
    /// let x1 = RescheduleMaintenanceRequest::new().set_reschedule_type(RescheduleType::NextAvailableWindow);
    /// let x2 = RescheduleMaintenanceRequest::new().set_reschedule_type(RescheduleType::SpecificTime);
    /// ```
    pub fn set_reschedule_type<
        T: std::convert::Into<crate::model::reschedule_maintenance_request::RescheduleType>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.reschedule_type = v.into();
        self
    }

    /// Sets the value of [schedule_time][crate::model::RescheduleMaintenanceRequest::schedule_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::RescheduleMaintenanceRequest;
    /// use wkt::Timestamp;
    /// let x = RescheduleMaintenanceRequest::new().set_schedule_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_schedule_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.schedule_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [schedule_time][crate::model::RescheduleMaintenanceRequest::schedule_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::RescheduleMaintenanceRequest;
    /// use wkt::Timestamp;
    /// let x = RescheduleMaintenanceRequest::new().set_or_clear_schedule_time(Some(Timestamp::default()/* use setters */));
    /// let x = RescheduleMaintenanceRequest::new().set_or_clear_schedule_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_schedule_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.schedule_time = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for RescheduleMaintenanceRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.redis.v1.RescheduleMaintenanceRequest"
    }
}

/// Defines additional types related to [RescheduleMaintenanceRequest].
pub mod reschedule_maintenance_request {
    #[allow(unused_imports)]
    use super::*;

    /// Reschedule options.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum RescheduleType {
        /// Not set.
        Unspecified,
        /// If the user wants to schedule the maintenance to happen now.
        Immediate,
        /// If the user wants to use the existing maintenance policy to find the
        /// next available window.
        NextAvailableWindow,
        /// If the user wants to reschedule the maintenance to a specific time.
        SpecificTime,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [RescheduleType::value] or
        /// [RescheduleType::name].
        UnknownValue(reschedule_type::UnknownValue),
    }

    #[doc(hidden)]
    pub mod reschedule_type {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl RescheduleType {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Immediate => std::option::Option::Some(1),
                Self::NextAvailableWindow => std::option::Option::Some(2),
                Self::SpecificTime => std::option::Option::Some(3),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("RESCHEDULE_TYPE_UNSPECIFIED"),
                Self::Immediate => std::option::Option::Some("IMMEDIATE"),
                Self::NextAvailableWindow => std::option::Option::Some("NEXT_AVAILABLE_WINDOW"),
                Self::SpecificTime => std::option::Option::Some("SPECIFIC_TIME"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for RescheduleType {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for RescheduleType {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for RescheduleType {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Immediate,
                2 => Self::NextAvailableWindow,
                3 => Self::SpecificTime,
                _ => Self::UnknownValue(reschedule_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for RescheduleType {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "RESCHEDULE_TYPE_UNSPECIFIED" => Self::Unspecified,
                "IMMEDIATE" => Self::Immediate,
                "NEXT_AVAILABLE_WINDOW" => Self::NextAvailableWindow,
                "SPECIFIC_TIME" => Self::SpecificTime,
                _ => Self::UnknownValue(reschedule_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for RescheduleType {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Immediate => serializer.serialize_i32(1),
                Self::NextAvailableWindow => serializer.serialize_i32(2),
                Self::SpecificTime => serializer.serialize_i32(3),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for RescheduleType {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<RescheduleType>::new(
                ".google.cloud.redis.v1.RescheduleMaintenanceRequest.RescheduleType",
            ))
        }
    }
}

/// Maintenance policy for an instance.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct MaintenancePolicy {
    /// Output only. The time when the policy was created.
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The time when the policy was last updated.
    pub update_time: std::option::Option<wkt::Timestamp>,

    /// Optional. Description of what this policy is for. Create/Update methods
    /// return INVALID_ARGUMENT if the length is greater than 512.
    pub description: std::string::String,

    /// Optional. Maintenance window that is applied to resources covered by this
    /// policy. Minimum 1. For the current version, the maximum number of
    /// weekly_window is expected to be one.
    pub weekly_maintenance_window: std::vec::Vec<crate::model::WeeklyMaintenanceWindow>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl MaintenancePolicy {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [create_time][crate::model::MaintenancePolicy::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::MaintenancePolicy;
    /// use wkt::Timestamp;
    /// let x = MaintenancePolicy::new().set_create_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_create_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.create_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [create_time][crate::model::MaintenancePolicy::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::MaintenancePolicy;
    /// use wkt::Timestamp;
    /// let x = MaintenancePolicy::new().set_or_clear_create_time(Some(Timestamp::default()/* use setters */));
    /// let x = MaintenancePolicy::new().set_or_clear_create_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_create_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.create_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [update_time][crate::model::MaintenancePolicy::update_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::MaintenancePolicy;
    /// use wkt::Timestamp;
    /// let x = MaintenancePolicy::new().set_update_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_update_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.update_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [update_time][crate::model::MaintenancePolicy::update_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::MaintenancePolicy;
    /// use wkt::Timestamp;
    /// let x = MaintenancePolicy::new().set_or_clear_update_time(Some(Timestamp::default()/* use setters */));
    /// let x = MaintenancePolicy::new().set_or_clear_update_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_update_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.update_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [description][crate::model::MaintenancePolicy::description].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::MaintenancePolicy;
    /// let x = MaintenancePolicy::new().set_description("example");
    /// ```
    pub fn set_description<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.description = v.into();
        self
    }

    /// Sets the value of [weekly_maintenance_window][crate::model::MaintenancePolicy::weekly_maintenance_window].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::MaintenancePolicy;
    /// use google_cloud_redis_v1::model::WeeklyMaintenanceWindow;
    /// let x = MaintenancePolicy::new()
    ///     .set_weekly_maintenance_window([
    ///         WeeklyMaintenanceWindow::default()/* use setters */,
    ///         WeeklyMaintenanceWindow::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_weekly_maintenance_window<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::WeeklyMaintenanceWindow>,
    {
        use std::iter::Iterator;
        self.weekly_maintenance_window = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for MaintenancePolicy {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.redis.v1.MaintenancePolicy"
    }
}

/// Time window in which disruptive maintenance updates occur. Non-disruptive
/// updates can occur inside or outside this window.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct WeeklyMaintenanceWindow {
    /// Required. The day of week that maintenance updates occur.
    pub day: gtype::model::DayOfWeek,

    /// Required. Start time of the window in UTC time.
    pub start_time: std::option::Option<gtype::model::TimeOfDay>,

    /// Output only. Duration of the maintenance window. The current window is
    /// fixed at 1 hour.
    pub duration: std::option::Option<wkt::Duration>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl WeeklyMaintenanceWindow {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [day][crate::model::WeeklyMaintenanceWindow::day].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::WeeklyMaintenanceWindow;
    /// use gtype::model::DayOfWeek;
    /// let x0 = WeeklyMaintenanceWindow::new().set_day(DayOfWeek::Monday);
    /// let x1 = WeeklyMaintenanceWindow::new().set_day(DayOfWeek::Tuesday);
    /// let x2 = WeeklyMaintenanceWindow::new().set_day(DayOfWeek::Wednesday);
    /// ```
    pub fn set_day<T: std::convert::Into<gtype::model::DayOfWeek>>(mut self, v: T) -> Self {
        self.day = v.into();
        self
    }

    /// Sets the value of [start_time][crate::model::WeeklyMaintenanceWindow::start_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::WeeklyMaintenanceWindow;
    /// use gtype::model::TimeOfDay;
    /// let x = WeeklyMaintenanceWindow::new().set_start_time(TimeOfDay::default()/* use setters */);
    /// ```
    pub fn set_start_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<gtype::model::TimeOfDay>,
    {
        self.start_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [start_time][crate::model::WeeklyMaintenanceWindow::start_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::WeeklyMaintenanceWindow;
    /// use gtype::model::TimeOfDay;
    /// let x = WeeklyMaintenanceWindow::new().set_or_clear_start_time(Some(TimeOfDay::default()/* use setters */));
    /// let x = WeeklyMaintenanceWindow::new().set_or_clear_start_time(None::<TimeOfDay>);
    /// ```
    pub fn set_or_clear_start_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<gtype::model::TimeOfDay>,
    {
        self.start_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [duration][crate::model::WeeklyMaintenanceWindow::duration].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::WeeklyMaintenanceWindow;
    /// use wkt::Duration;
    /// let x = WeeklyMaintenanceWindow::new().set_duration(Duration::default()/* use setters */);
    /// ```
    pub fn set_duration<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Duration>,
    {
        self.duration = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [duration][crate::model::WeeklyMaintenanceWindow::duration].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::WeeklyMaintenanceWindow;
    /// use wkt::Duration;
    /// let x = WeeklyMaintenanceWindow::new().set_or_clear_duration(Some(Duration::default()/* use setters */));
    /// let x = WeeklyMaintenanceWindow::new().set_or_clear_duration(None::<Duration>);
    /// ```
    pub fn set_or_clear_duration<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Duration>,
    {
        self.duration = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for WeeklyMaintenanceWindow {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.redis.v1.WeeklyMaintenanceWindow"
    }
}

/// Upcoming maintenance schedule. If no maintenance is scheduled, fields are not
/// populated.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct MaintenanceSchedule {
    /// Output only. The start time of any upcoming scheduled maintenance for this
    /// instance.
    pub start_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The end time of any upcoming scheduled maintenance for this
    /// instance.
    pub end_time: std::option::Option<wkt::Timestamp>,

    /// If the scheduled maintenance can be rescheduled, default is true.
    #[deprecated]
    pub can_reschedule: bool,

    /// Output only. The deadline that the maintenance schedule start time can not
    /// go beyond, including reschedule.
    pub schedule_deadline_time: std::option::Option<wkt::Timestamp>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl MaintenanceSchedule {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [start_time][crate::model::MaintenanceSchedule::start_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::MaintenanceSchedule;
    /// use wkt::Timestamp;
    /// let x = MaintenanceSchedule::new().set_start_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_start_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.start_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [start_time][crate::model::MaintenanceSchedule::start_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::MaintenanceSchedule;
    /// use wkt::Timestamp;
    /// let x = MaintenanceSchedule::new().set_or_clear_start_time(Some(Timestamp::default()/* use setters */));
    /// let x = MaintenanceSchedule::new().set_or_clear_start_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_start_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.start_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [end_time][crate::model::MaintenanceSchedule::end_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::MaintenanceSchedule;
    /// use wkt::Timestamp;
    /// let x = MaintenanceSchedule::new().set_end_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_end_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.end_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [end_time][crate::model::MaintenanceSchedule::end_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::MaintenanceSchedule;
    /// use wkt::Timestamp;
    /// let x = MaintenanceSchedule::new().set_or_clear_end_time(Some(Timestamp::default()/* use setters */));
    /// let x = MaintenanceSchedule::new().set_or_clear_end_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_end_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.end_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [can_reschedule][crate::model::MaintenanceSchedule::can_reschedule].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::MaintenanceSchedule;
    /// let x = MaintenanceSchedule::new().set_can_reschedule(true);
    /// ```
    #[deprecated]
    pub fn set_can_reschedule<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.can_reschedule = v.into();
        self
    }

    /// Sets the value of [schedule_deadline_time][crate::model::MaintenanceSchedule::schedule_deadline_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::MaintenanceSchedule;
    /// use wkt::Timestamp;
    /// let x = MaintenanceSchedule::new().set_schedule_deadline_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_schedule_deadline_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.schedule_deadline_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [schedule_deadline_time][crate::model::MaintenanceSchedule::schedule_deadline_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::MaintenanceSchedule;
    /// use wkt::Timestamp;
    /// let x = MaintenanceSchedule::new().set_or_clear_schedule_deadline_time(Some(Timestamp::default()/* use setters */));
    /// let x = MaintenanceSchedule::new().set_or_clear_schedule_deadline_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_schedule_deadline_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.schedule_deadline_time = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for MaintenanceSchedule {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.redis.v1.MaintenanceSchedule"
    }
}

/// Request for [ListInstances][google.cloud.redis.v1.CloudRedis.ListInstances].
///
/// [google.cloud.redis.v1.CloudRedis.ListInstances]: crate::client::CloudRedis::list_instances
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListInstancesRequest {
    /// Required. The resource name of the instance location using the form:
    /// `projects/{project_id}/locations/{location_id}`
    /// where `location_id` refers to a GCP region.
    pub parent: std::string::String,

    /// The maximum number of items to return.
    ///
    /// If not specified, a default value of 1000 will be used by the service.
    /// Regardless of the page_size value, the response may include a partial list
    /// and a caller should only rely on response's
    /// [`next_page_token`][google.cloud.redis.v1.ListInstancesResponse.next_page_token]
    /// to determine if there are more instances left to be queried.
    ///
    /// [google.cloud.redis.v1.ListInstancesResponse.next_page_token]: crate::model::ListInstancesResponse::next_page_token
    pub page_size: i32,

    /// The `next_page_token` value returned from a previous
    /// [ListInstances][google.cloud.redis.v1.CloudRedis.ListInstances] request, if
    /// any.
    ///
    /// [google.cloud.redis.v1.CloudRedis.ListInstances]: crate::client::CloudRedis::list_instances
    pub page_token: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ListInstancesRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::ListInstancesRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::ListInstancesRequest;
    /// let x = ListInstancesRequest::new().set_parent("example");
    /// ```
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [page_size][crate::model::ListInstancesRequest::page_size].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::ListInstancesRequest;
    /// let x = ListInstancesRequest::new().set_page_size(42);
    /// ```
    pub fn set_page_size<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.page_size = v.into();
        self
    }

    /// Sets the value of [page_token][crate::model::ListInstancesRequest::page_token].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::ListInstancesRequest;
    /// let x = ListInstancesRequest::new().set_page_token("example");
    /// ```
    pub fn set_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.page_token = v.into();
        self
    }
}

impl wkt::message::Message for ListInstancesRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.redis.v1.ListInstancesRequest"
    }
}

/// Response for [ListInstances][google.cloud.redis.v1.CloudRedis.ListInstances].
///
/// [google.cloud.redis.v1.CloudRedis.ListInstances]: crate::client::CloudRedis::list_instances
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListInstancesResponse {
    /// A list of Redis instances in the project in the specified location,
    /// or across all locations.
    ///
    /// If the `location_id` in the parent field of the request is "-", all regions
    /// available to the project are queried, and the results aggregated.
    /// If in such an aggregated query a location is unavailable, a placeholder
    /// Redis entry is included in the response with the `name` field set to a
    /// value of the form
    /// `projects/{project_id}/locations/{location_id}/instances/`- and the
    /// `status` field set to ERROR and `status_message` field set to "location not
    /// available for ListInstances".
    pub instances: std::vec::Vec<crate::model::Instance>,

    /// Token to retrieve the next page of results, or empty if there are no more
    /// results in the list.
    pub next_page_token: std::string::String,

    /// Locations that could not be reached.
    pub unreachable: std::vec::Vec<std::string::String>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ListInstancesResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [instances][crate::model::ListInstancesResponse::instances].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::ListInstancesResponse;
    /// use google_cloud_redis_v1::model::Instance;
    /// let x = ListInstancesResponse::new()
    ///     .set_instances([
    ///         Instance::default()/* use setters */,
    ///         Instance::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_instances<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::Instance>,
    {
        use std::iter::Iterator;
        self.instances = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [next_page_token][crate::model::ListInstancesResponse::next_page_token].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::ListInstancesResponse;
    /// let x = ListInstancesResponse::new().set_next_page_token("example");
    /// ```
    pub fn set_next_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.next_page_token = v.into();
        self
    }

    /// Sets the value of [unreachable][crate::model::ListInstancesResponse::unreachable].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::ListInstancesResponse;
    /// let x = ListInstancesResponse::new().set_unreachable(["a", "b", "c"]);
    /// ```
    pub fn set_unreachable<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.unreachable = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for ListInstancesResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.redis.v1.ListInstancesResponse"
    }
}

#[doc(hidden)]
impl gax::paginator::internal::PageableResponse for ListInstancesResponse {
    type PageItem = crate::model::Instance;

    fn items(self) -> std::vec::Vec<Self::PageItem> {
        self.instances
    }

    fn next_page_token(&self) -> std::string::String {
        use std::clone::Clone;
        self.next_page_token.clone()
    }
}

/// Request for [GetInstance][google.cloud.redis.v1.CloudRedis.GetInstance].
///
/// [google.cloud.redis.v1.CloudRedis.GetInstance]: crate::client::CloudRedis::get_instance
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GetInstanceRequest {
    /// Required. Redis instance resource name using the form:
    /// `projects/{project_id}/locations/{location_id}/instances/{instance_id}`
    /// where `location_id` refers to a GCP region.
    pub name: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl GetInstanceRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::GetInstanceRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::GetInstanceRequest;
    /// let x = GetInstanceRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for GetInstanceRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.redis.v1.GetInstanceRequest"
    }
}

/// Request for
/// [GetInstanceAuthString][google.cloud.redis.v1.CloudRedis.GetInstanceAuthString].
///
/// [google.cloud.redis.v1.CloudRedis.GetInstanceAuthString]: crate::client::CloudRedis::get_instance_auth_string
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GetInstanceAuthStringRequest {
    /// Required. Redis instance resource name using the form:
    /// `projects/{project_id}/locations/{location_id}/instances/{instance_id}`
    /// where `location_id` refers to a GCP region.
    pub name: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl GetInstanceAuthStringRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::GetInstanceAuthStringRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::GetInstanceAuthStringRequest;
    /// let x = GetInstanceAuthStringRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for GetInstanceAuthStringRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.redis.v1.GetInstanceAuthStringRequest"
    }
}

/// Instance AUTH string details.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct InstanceAuthString {
    /// AUTH string set on the instance.
    pub auth_string: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl InstanceAuthString {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [auth_string][crate::model::InstanceAuthString::auth_string].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::InstanceAuthString;
    /// let x = InstanceAuthString::new().set_auth_string("example");
    /// ```
    pub fn set_auth_string<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.auth_string = v.into();
        self
    }
}

impl wkt::message::Message for InstanceAuthString {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.redis.v1.InstanceAuthString"
    }
}

/// Request for
/// [CreateInstance][google.cloud.redis.v1.CloudRedis.CreateInstance].
///
/// [google.cloud.redis.v1.CloudRedis.CreateInstance]: crate::client::CloudRedis::create_instance
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CreateInstanceRequest {
    /// Required. The resource name of the instance location using the form:
    /// `projects/{project_id}/locations/{location_id}`
    /// where `location_id` refers to a GCP region.
    pub parent: std::string::String,

    /// Required. The logical name of the Redis instance in the customer project
    /// with the following restrictions:
    ///
    /// * Must contain only lowercase letters, numbers, and hyphens.
    /// * Must start with a letter.
    /// * Must be between 1-40 characters.
    /// * Must end with a number or a letter.
    /// * Must be unique within the customer project / location
    pub instance_id: std::string::String,

    /// Required. A Redis [Instance] resource
    pub instance: std::option::Option<crate::model::Instance>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl CreateInstanceRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::CreateInstanceRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::CreateInstanceRequest;
    /// let x = CreateInstanceRequest::new().set_parent("example");
    /// ```
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [instance_id][crate::model::CreateInstanceRequest::instance_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::CreateInstanceRequest;
    /// let x = CreateInstanceRequest::new().set_instance_id("example");
    /// ```
    pub fn set_instance_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.instance_id = v.into();
        self
    }

    /// Sets the value of [instance][crate::model::CreateInstanceRequest::instance].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::CreateInstanceRequest;
    /// use google_cloud_redis_v1::model::Instance;
    /// let x = CreateInstanceRequest::new().set_instance(Instance::default()/* use setters */);
    /// ```
    pub fn set_instance<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::Instance>,
    {
        self.instance = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [instance][crate::model::CreateInstanceRequest::instance].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::CreateInstanceRequest;
    /// use google_cloud_redis_v1::model::Instance;
    /// let x = CreateInstanceRequest::new().set_or_clear_instance(Some(Instance::default()/* use setters */));
    /// let x = CreateInstanceRequest::new().set_or_clear_instance(None::<Instance>);
    /// ```
    pub fn set_or_clear_instance<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::Instance>,
    {
        self.instance = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for CreateInstanceRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.redis.v1.CreateInstanceRequest"
    }
}

/// Request for
/// [UpdateInstance][google.cloud.redis.v1.CloudRedis.UpdateInstance].
///
/// [google.cloud.redis.v1.CloudRedis.UpdateInstance]: crate::client::CloudRedis::update_instance
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct UpdateInstanceRequest {
    /// Required. Mask of fields to update. At least one path must be supplied in
    /// this field. The elements of the repeated paths field may only include these
    /// fields from [Instance][google.cloud.redis.v1.Instance]:
    ///
    /// * `displayName`
    /// * `labels`
    /// * `memorySizeGb`
    /// * `redisConfig`
    /// * `replica_count`
    ///
    /// [google.cloud.redis.v1.Instance]: crate::model::Instance
    pub update_mask: std::option::Option<wkt::FieldMask>,

    /// Required. Update description.
    /// Only fields specified in update_mask are updated.
    pub instance: std::option::Option<crate::model::Instance>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl UpdateInstanceRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [update_mask][crate::model::UpdateInstanceRequest::update_mask].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::UpdateInstanceRequest;
    /// use wkt::FieldMask;
    /// let x = UpdateInstanceRequest::new().set_update_mask(FieldMask::default()/* use setters */);
    /// ```
    pub fn set_update_mask<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::FieldMask>,
    {
        self.update_mask = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [update_mask][crate::model::UpdateInstanceRequest::update_mask].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::UpdateInstanceRequest;
    /// use wkt::FieldMask;
    /// let x = UpdateInstanceRequest::new().set_or_clear_update_mask(Some(FieldMask::default()/* use setters */));
    /// let x = UpdateInstanceRequest::new().set_or_clear_update_mask(None::<FieldMask>);
    /// ```
    pub fn set_or_clear_update_mask<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::FieldMask>,
    {
        self.update_mask = v.map(|x| x.into());
        self
    }

    /// Sets the value of [instance][crate::model::UpdateInstanceRequest::instance].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::UpdateInstanceRequest;
    /// use google_cloud_redis_v1::model::Instance;
    /// let x = UpdateInstanceRequest::new().set_instance(Instance::default()/* use setters */);
    /// ```
    pub fn set_instance<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::Instance>,
    {
        self.instance = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [instance][crate::model::UpdateInstanceRequest::instance].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::UpdateInstanceRequest;
    /// use google_cloud_redis_v1::model::Instance;
    /// let x = UpdateInstanceRequest::new().set_or_clear_instance(Some(Instance::default()/* use setters */));
    /// let x = UpdateInstanceRequest::new().set_or_clear_instance(None::<Instance>);
    /// ```
    pub fn set_or_clear_instance<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::Instance>,
    {
        self.instance = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for UpdateInstanceRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.redis.v1.UpdateInstanceRequest"
    }
}

/// Request for
/// [UpgradeInstance][google.cloud.redis.v1.CloudRedis.UpgradeInstance].
///
/// [google.cloud.redis.v1.CloudRedis.UpgradeInstance]: crate::client::CloudRedis::upgrade_instance
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct UpgradeInstanceRequest {
    /// Required. Redis instance resource name using the form:
    /// `projects/{project_id}/locations/{location_id}/instances/{instance_id}`
    /// where `location_id` refers to a GCP region.
    pub name: std::string::String,

    /// Required. Specifies the target version of Redis software to upgrade to.
    pub redis_version: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl UpgradeInstanceRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::UpgradeInstanceRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::UpgradeInstanceRequest;
    /// let x = UpgradeInstanceRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [redis_version][crate::model::UpgradeInstanceRequest::redis_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::UpgradeInstanceRequest;
    /// let x = UpgradeInstanceRequest::new().set_redis_version("example");
    /// ```
    pub fn set_redis_version<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.redis_version = v.into();
        self
    }
}

impl wkt::message::Message for UpgradeInstanceRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.redis.v1.UpgradeInstanceRequest"
    }
}

/// Request for
/// [DeleteInstance][google.cloud.redis.v1.CloudRedis.DeleteInstance].
///
/// [google.cloud.redis.v1.CloudRedis.DeleteInstance]: crate::client::CloudRedis::delete_instance
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DeleteInstanceRequest {
    /// Required. Redis instance resource name using the form:
    /// `projects/{project_id}/locations/{location_id}/instances/{instance_id}`
    /// where `location_id` refers to a GCP region.
    pub name: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl DeleteInstanceRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::DeleteInstanceRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::DeleteInstanceRequest;
    /// let x = DeleteInstanceRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for DeleteInstanceRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.redis.v1.DeleteInstanceRequest"
    }
}

/// The Cloud Storage location for the input content
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GcsSource {
    /// Required. Source data URI. (e.g. 'gs://my_bucket/my_object').
    pub uri: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl GcsSource {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [uri][crate::model::GcsSource::uri].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::GcsSource;
    /// let x = GcsSource::new().set_uri("example");
    /// ```
    pub fn set_uri<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.uri = v.into();
        self
    }
}

impl wkt::message::Message for GcsSource {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.redis.v1.GcsSource"
    }
}

/// The input content
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct InputConfig {
    /// Required. Specify source location of input data
    pub source: std::option::Option<crate::model::input_config::Source>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl InputConfig {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [source][crate::model::InputConfig::source].
    ///
    /// Note that all the setters affecting `source` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::InputConfig;
    /// use google_cloud_redis_v1::model::GcsSource;
    /// let x = InputConfig::new().set_source(Some(
    ///     google_cloud_redis_v1::model::input_config::Source::GcsSource(GcsSource::default().into())));
    /// ```
    pub fn set_source<
        T: std::convert::Into<std::option::Option<crate::model::input_config::Source>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.source = v.into();
        self
    }

    /// The value of [source][crate::model::InputConfig::source]
    /// if it holds a `GcsSource`, `None` if the field is not set or
    /// holds a different branch.
    pub fn gcs_source(&self) -> std::option::Option<&std::boxed::Box<crate::model::GcsSource>> {
        #[allow(unreachable_patterns)]
        self.source.as_ref().and_then(|v| match v {
            crate::model::input_config::Source::GcsSource(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [source][crate::model::InputConfig::source]
    /// to hold a `GcsSource`.
    ///
    /// Note that all the setters affecting `source` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::InputConfig;
    /// use google_cloud_redis_v1::model::GcsSource;
    /// let x = InputConfig::new().set_gcs_source(GcsSource::default()/* use setters */);
    /// assert!(x.gcs_source().is_some());
    /// ```
    pub fn set_gcs_source<T: std::convert::Into<std::boxed::Box<crate::model::GcsSource>>>(
        mut self,
        v: T,
    ) -> Self {
        self.source =
            std::option::Option::Some(crate::model::input_config::Source::GcsSource(v.into()));
        self
    }
}

impl wkt::message::Message for InputConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.redis.v1.InputConfig"
    }
}

/// Defines additional types related to [InputConfig].
pub mod input_config {
    #[allow(unused_imports)]
    use super::*;

    /// Required. Specify source location of input data
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Source {
        /// Google Cloud Storage location where input content is located.
        GcsSource(std::boxed::Box<crate::model::GcsSource>),
    }
}

/// Request for [Import][google.cloud.redis.v1.CloudRedis.ImportInstance].
///
/// [google.cloud.redis.v1.CloudRedis.ImportInstance]: crate::client::CloudRedis::import_instance
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ImportInstanceRequest {
    /// Required. Redis instance resource name using the form:
    /// `projects/{project_id}/locations/{location_id}/instances/{instance_id}`
    /// where `location_id` refers to a GCP region.
    pub name: std::string::String,

    /// Required. Specify data to be imported.
    pub input_config: std::option::Option<crate::model::InputConfig>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ImportInstanceRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::ImportInstanceRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::ImportInstanceRequest;
    /// let x = ImportInstanceRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [input_config][crate::model::ImportInstanceRequest::input_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::ImportInstanceRequest;
    /// use google_cloud_redis_v1::model::InputConfig;
    /// let x = ImportInstanceRequest::new().set_input_config(InputConfig::default()/* use setters */);
    /// ```
    pub fn set_input_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::InputConfig>,
    {
        self.input_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [input_config][crate::model::ImportInstanceRequest::input_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::ImportInstanceRequest;
    /// use google_cloud_redis_v1::model::InputConfig;
    /// let x = ImportInstanceRequest::new().set_or_clear_input_config(Some(InputConfig::default()/* use setters */));
    /// let x = ImportInstanceRequest::new().set_or_clear_input_config(None::<InputConfig>);
    /// ```
    pub fn set_or_clear_input_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::InputConfig>,
    {
        self.input_config = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for ImportInstanceRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.redis.v1.ImportInstanceRequest"
    }
}

/// The Cloud Storage location for the output content
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GcsDestination {
    /// Required. Data destination URI (e.g.
    /// 'gs://my_bucket/my_object'). Existing files will be overwritten.
    pub uri: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl GcsDestination {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [uri][crate::model::GcsDestination::uri].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::GcsDestination;
    /// let x = GcsDestination::new().set_uri("example");
    /// ```
    pub fn set_uri<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.uri = v.into();
        self
    }
}

impl wkt::message::Message for GcsDestination {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.redis.v1.GcsDestination"
    }
}

/// The output content
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct OutputConfig {
    /// Required. Specify destination location of output data
    pub destination: std::option::Option<crate::model::output_config::Destination>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl OutputConfig {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [destination][crate::model::OutputConfig::destination].
    ///
    /// Note that all the setters affecting `destination` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::OutputConfig;
    /// use google_cloud_redis_v1::model::GcsDestination;
    /// let x = OutputConfig::new().set_destination(Some(
    ///     google_cloud_redis_v1::model::output_config::Destination::GcsDestination(GcsDestination::default().into())));
    /// ```
    pub fn set_destination<
        T: std::convert::Into<std::option::Option<crate::model::output_config::Destination>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.destination = v.into();
        self
    }

    /// The value of [destination][crate::model::OutputConfig::destination]
    /// if it holds a `GcsDestination`, `None` if the field is not set or
    /// holds a different branch.
    pub fn gcs_destination(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::GcsDestination>> {
        #[allow(unreachable_patterns)]
        self.destination.as_ref().and_then(|v| match v {
            crate::model::output_config::Destination::GcsDestination(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [destination][crate::model::OutputConfig::destination]
    /// to hold a `GcsDestination`.
    ///
    /// Note that all the setters affecting `destination` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::OutputConfig;
    /// use google_cloud_redis_v1::model::GcsDestination;
    /// let x = OutputConfig::new().set_gcs_destination(GcsDestination::default()/* use setters */);
    /// assert!(x.gcs_destination().is_some());
    /// ```
    pub fn set_gcs_destination<
        T: std::convert::Into<std::boxed::Box<crate::model::GcsDestination>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.destination = std::option::Option::Some(
            crate::model::output_config::Destination::GcsDestination(v.into()),
        );
        self
    }
}

impl wkt::message::Message for OutputConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.redis.v1.OutputConfig"
    }
}

/// Defines additional types related to [OutputConfig].
pub mod output_config {
    #[allow(unused_imports)]
    use super::*;

    /// Required. Specify destination location of output data
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Destination {
        /// Google Cloud Storage destination for output content.
        GcsDestination(std::boxed::Box<crate::model::GcsDestination>),
    }
}

/// Request for [Export][google.cloud.redis.v1.CloudRedis.ExportInstance].
///
/// [google.cloud.redis.v1.CloudRedis.ExportInstance]: crate::client::CloudRedis::export_instance
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ExportInstanceRequest {
    /// Required. Redis instance resource name using the form:
    /// `projects/{project_id}/locations/{location_id}/instances/{instance_id}`
    /// where `location_id` refers to a GCP region.
    pub name: std::string::String,

    /// Required. Specify data to be exported.
    pub output_config: std::option::Option<crate::model::OutputConfig>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ExportInstanceRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::ExportInstanceRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::ExportInstanceRequest;
    /// let x = ExportInstanceRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [output_config][crate::model::ExportInstanceRequest::output_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::ExportInstanceRequest;
    /// use google_cloud_redis_v1::model::OutputConfig;
    /// let x = ExportInstanceRequest::new().set_output_config(OutputConfig::default()/* use setters */);
    /// ```
    pub fn set_output_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::OutputConfig>,
    {
        self.output_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [output_config][crate::model::ExportInstanceRequest::output_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::ExportInstanceRequest;
    /// use google_cloud_redis_v1::model::OutputConfig;
    /// let x = ExportInstanceRequest::new().set_or_clear_output_config(Some(OutputConfig::default()/* use setters */));
    /// let x = ExportInstanceRequest::new().set_or_clear_output_config(None::<OutputConfig>);
    /// ```
    pub fn set_or_clear_output_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::OutputConfig>,
    {
        self.output_config = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for ExportInstanceRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.redis.v1.ExportInstanceRequest"
    }
}

/// Request for [Failover][google.cloud.redis.v1.CloudRedis.FailoverInstance].
///
/// [google.cloud.redis.v1.CloudRedis.FailoverInstance]: crate::client::CloudRedis::failover_instance
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct FailoverInstanceRequest {
    /// Required. Redis instance resource name using the form:
    /// `projects/{project_id}/locations/{location_id}/instances/{instance_id}`
    /// where `location_id` refers to a GCP region.
    pub name: std::string::String,

    /// Optional. Available data protection modes that the user can choose. If it's
    /// unspecified, data protection mode will be LIMITED_DATA_LOSS by default.
    pub data_protection_mode: crate::model::failover_instance_request::DataProtectionMode,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl FailoverInstanceRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::FailoverInstanceRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::FailoverInstanceRequest;
    /// let x = FailoverInstanceRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [data_protection_mode][crate::model::FailoverInstanceRequest::data_protection_mode].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::FailoverInstanceRequest;
    /// use google_cloud_redis_v1::model::failover_instance_request::DataProtectionMode;
    /// let x0 = FailoverInstanceRequest::new().set_data_protection_mode(DataProtectionMode::LimitedDataLoss);
    /// let x1 = FailoverInstanceRequest::new().set_data_protection_mode(DataProtectionMode::ForceDataLoss);
    /// ```
    pub fn set_data_protection_mode<
        T: std::convert::Into<crate::model::failover_instance_request::DataProtectionMode>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.data_protection_mode = v.into();
        self
    }
}

impl wkt::message::Message for FailoverInstanceRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.redis.v1.FailoverInstanceRequest"
    }
}

/// Defines additional types related to [FailoverInstanceRequest].
pub mod failover_instance_request {
    #[allow(unused_imports)]
    use super::*;

    /// Specifies different modes of operation in relation to the data retention.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum DataProtectionMode {
        /// Defaults to LIMITED_DATA_LOSS if a data protection mode is not
        /// specified.
        Unspecified,
        /// Instance failover will be protected with data loss control. More
        /// specifically, the failover will only be performed if the current
        /// replication offset diff between primary and replica is under a certain
        /// threshold.
        LimitedDataLoss,
        /// Instance failover will be performed without data loss control.
        ForceDataLoss,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [DataProtectionMode::value] or
        /// [DataProtectionMode::name].
        UnknownValue(data_protection_mode::UnknownValue),
    }

    #[doc(hidden)]
    pub mod data_protection_mode {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl DataProtectionMode {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::LimitedDataLoss => std::option::Option::Some(1),
                Self::ForceDataLoss => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("DATA_PROTECTION_MODE_UNSPECIFIED"),
                Self::LimitedDataLoss => std::option::Option::Some("LIMITED_DATA_LOSS"),
                Self::ForceDataLoss => std::option::Option::Some("FORCE_DATA_LOSS"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for DataProtectionMode {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for DataProtectionMode {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for DataProtectionMode {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::LimitedDataLoss,
                2 => Self::ForceDataLoss,
                _ => Self::UnknownValue(data_protection_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for DataProtectionMode {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "DATA_PROTECTION_MODE_UNSPECIFIED" => Self::Unspecified,
                "LIMITED_DATA_LOSS" => Self::LimitedDataLoss,
                "FORCE_DATA_LOSS" => Self::ForceDataLoss,
                _ => Self::UnknownValue(data_protection_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for DataProtectionMode {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::LimitedDataLoss => serializer.serialize_i32(1),
                Self::ForceDataLoss => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for DataProtectionMode {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<DataProtectionMode>::new(
                ".google.cloud.redis.v1.FailoverInstanceRequest.DataProtectionMode",
            ))
        }
    }
}

/// Represents the v1 metadata of the long-running operation.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct OperationMetadata {
    /// Creation timestamp.
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// End timestamp.
    pub end_time: std::option::Option<wkt::Timestamp>,

    /// Operation target.
    pub target: std::string::String,

    /// Operation verb.
    pub verb: std::string::String,

    /// Operation status details.
    pub status_detail: std::string::String,

    /// Specifies if cancellation was requested for the operation.
    pub cancel_requested: bool,

    /// API version.
    pub api_version: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl OperationMetadata {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [create_time][crate::model::OperationMetadata::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::OperationMetadata;
    /// use wkt::Timestamp;
    /// let x = OperationMetadata::new().set_create_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_create_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.create_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [create_time][crate::model::OperationMetadata::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::OperationMetadata;
    /// use wkt::Timestamp;
    /// let x = OperationMetadata::new().set_or_clear_create_time(Some(Timestamp::default()/* use setters */));
    /// let x = OperationMetadata::new().set_or_clear_create_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_create_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.create_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [end_time][crate::model::OperationMetadata::end_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::OperationMetadata;
    /// use wkt::Timestamp;
    /// let x = OperationMetadata::new().set_end_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_end_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.end_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [end_time][crate::model::OperationMetadata::end_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::OperationMetadata;
    /// use wkt::Timestamp;
    /// let x = OperationMetadata::new().set_or_clear_end_time(Some(Timestamp::default()/* use setters */));
    /// let x = OperationMetadata::new().set_or_clear_end_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_end_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.end_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [target][crate::model::OperationMetadata::target].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::OperationMetadata;
    /// let x = OperationMetadata::new().set_target("example");
    /// ```
    pub fn set_target<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.target = v.into();
        self
    }

    /// Sets the value of [verb][crate::model::OperationMetadata::verb].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::OperationMetadata;
    /// let x = OperationMetadata::new().set_verb("example");
    /// ```
    pub fn set_verb<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.verb = v.into();
        self
    }

    /// Sets the value of [status_detail][crate::model::OperationMetadata::status_detail].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::OperationMetadata;
    /// let x = OperationMetadata::new().set_status_detail("example");
    /// ```
    pub fn set_status_detail<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.status_detail = v.into();
        self
    }

    /// Sets the value of [cancel_requested][crate::model::OperationMetadata::cancel_requested].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::OperationMetadata;
    /// let x = OperationMetadata::new().set_cancel_requested(true);
    /// ```
    pub fn set_cancel_requested<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.cancel_requested = v.into();
        self
    }

    /// Sets the value of [api_version][crate::model::OperationMetadata::api_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::OperationMetadata;
    /// let x = OperationMetadata::new().set_api_version("example");
    /// ```
    pub fn set_api_version<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.api_version = v.into();
        self
    }
}

impl wkt::message::Message for OperationMetadata {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.redis.v1.OperationMetadata"
    }
}

/// This location metadata represents additional configuration options for a
/// given location where a Redis instance may be created. All fields are output
/// only. It is returned as content of the
/// `google.cloud.location.Location.metadata` field.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct LocationMetadata {
    /// Output only. The set of available zones in the location. The map is keyed
    /// by the lowercase ID of each zone, as defined by GCE. These keys can be
    /// specified in `location_id` or `alternative_location_id` fields when
    /// creating a Redis instance.
    pub available_zones: std::collections::HashMap<std::string::String, crate::model::ZoneMetadata>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl LocationMetadata {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [available_zones][crate::model::LocationMetadata::available_zones].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::LocationMetadata;
    /// use google_cloud_redis_v1::model::ZoneMetadata;
    /// let x = LocationMetadata::new().set_available_zones([
    ///     ("key0", ZoneMetadata::default()/* use setters */),
    ///     ("key1", ZoneMetadata::default()/* use (different) setters */),
    /// ]);
    /// ```
    pub fn set_available_zones<T, K, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = (K, V)>,
        K: std::convert::Into<std::string::String>,
        V: std::convert::Into<crate::model::ZoneMetadata>,
    {
        use std::iter::Iterator;
        self.available_zones = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }
}

impl wkt::message::Message for LocationMetadata {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.redis.v1.LocationMetadata"
    }
}

/// Defines specific information for a particular zone. Currently empty and
/// reserved for future use only.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ZoneMetadata {
    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ZoneMetadata {
    pub fn new() -> Self {
        std::default::Default::default()
    }
}

impl wkt::message::Message for ZoneMetadata {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.redis.v1.ZoneMetadata"
    }
}

/// TlsCertificate Resource
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct TlsCertificate {
    /// Serial number, as extracted from the certificate.
    pub serial_number: std::string::String,

    /// PEM representation.
    pub cert: std::string::String,

    /// Output only. The time when the certificate was created in [RFC
    /// 3339](https://tools.ietf.org/html/rfc3339) format, for example
    /// `2020-05-18T00:00:00.094Z`.
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The time when the certificate expires in [RFC
    /// 3339](https://tools.ietf.org/html/rfc3339) format, for example
    /// `2020-05-18T00:00:00.094Z`.
    pub expire_time: std::option::Option<wkt::Timestamp>,

    /// Sha1 Fingerprint of the certificate.
    pub sha1_fingerprint: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl TlsCertificate {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [serial_number][crate::model::TlsCertificate::serial_number].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::TlsCertificate;
    /// let x = TlsCertificate::new().set_serial_number("example");
    /// ```
    pub fn set_serial_number<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.serial_number = v.into();
        self
    }

    /// Sets the value of [cert][crate::model::TlsCertificate::cert].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::TlsCertificate;
    /// let x = TlsCertificate::new().set_cert("example");
    /// ```
    pub fn set_cert<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.cert = v.into();
        self
    }

    /// Sets the value of [create_time][crate::model::TlsCertificate::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::TlsCertificate;
    /// use wkt::Timestamp;
    /// let x = TlsCertificate::new().set_create_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_create_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.create_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [create_time][crate::model::TlsCertificate::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::TlsCertificate;
    /// use wkt::Timestamp;
    /// let x = TlsCertificate::new().set_or_clear_create_time(Some(Timestamp::default()/* use setters */));
    /// let x = TlsCertificate::new().set_or_clear_create_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_create_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.create_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [expire_time][crate::model::TlsCertificate::expire_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::TlsCertificate;
    /// use wkt::Timestamp;
    /// let x = TlsCertificate::new().set_expire_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_expire_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.expire_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [expire_time][crate::model::TlsCertificate::expire_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::TlsCertificate;
    /// use wkt::Timestamp;
    /// let x = TlsCertificate::new().set_or_clear_expire_time(Some(Timestamp::default()/* use setters */));
    /// let x = TlsCertificate::new().set_or_clear_expire_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_expire_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.expire_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [sha1_fingerprint][crate::model::TlsCertificate::sha1_fingerprint].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_redis_v1::model::TlsCertificate;
    /// let x = TlsCertificate::new().set_sha1_fingerprint("example");
    /// ```
    pub fn set_sha1_fingerprint<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.sha1_fingerprint = v.into();
        self
    }
}

impl wkt::message::Message for TlsCertificate {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.redis.v1.TlsCertificate"
    }
}