google_cloud_memcache_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;

/// A Memorystore for Memcached 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: Memcached instances are managed and addressed at the regional level
    /// so `location_id` here refers to a Google Cloud region; however, users may
    /// choose which zones Memcached nodes should be provisioned in within an
    /// instance. Refer to [zones][google.cloud.memcache.v1.Instance.zones] field for more details.
    ///
    /// [google.cloud.memcache.v1.Instance.zones]: crate::model::Instance::zones
    pub name: std::string::String,

    /// User provided name for the instance, which is only used for display
    /// purposes. Cannot be more than 80 characters.
    pub display_name: std::string::String,

    /// Resource labels to represent user-provided metadata.
    /// Refer to cloud documentation on labels for more details.
    /// <https://cloud.google.com/compute/docs/labeling-resources>
    pub labels: std::collections::HashMap<std::string::String, std::string::String>,

    /// The full name of the Google Compute Engine
    /// [network](/compute/docs/networks-and-firewalls#networks) to which the
    /// instance is connected. If left unspecified, the `default` network
    /// will be used.
    pub authorized_network: std::string::String,

    /// Zones in which Memcached nodes should be provisioned.
    /// Memcached nodes will be equally distributed across these zones. If not
    /// provided, the service will by default create nodes in all zones in the
    /// region for the instance.
    pub zones: std::vec::Vec<std::string::String>,

    /// Required. Number of nodes in the Memcached instance.
    pub node_count: i32,

    /// Required. Configuration for Memcached nodes.
    pub node_config: std::option::Option<crate::model::instance::NodeConfig>,

    /// The major version of Memcached software.
    /// If not provided, latest supported version will be used. Currently the
    /// latest supported major version is `MEMCACHE_1_5`.
    /// The minor version will be automatically determined by our system based on
    /// the latest supported minor version.
    pub memcache_version: crate::model::MemcacheVersion,

    /// User defined parameters to apply to the memcached process
    /// on each node.
    pub parameters: std::option::Option<crate::model::MemcacheParameters>,

    /// Output only. List of Memcached nodes.
    /// Refer to [Node][google.cloud.memcache.v1.Instance.Node] message for more details.
    ///
    /// [google.cloud.memcache.v1.Instance.Node]: crate::model::instance::Node
    pub memcache_nodes: std::vec::Vec<crate::model::instance::Node>,

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

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

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

    /// Output only. The full version of memcached server running on this instance.
    /// System automatically determines the full memcached version for an instance
    /// based on the input MemcacheVersion.
    /// The full version format will be "memcached-1.5.16".
    pub memcache_full_version: std::string::String,

    /// List of messages that describe the current state of the Memcached instance.
    pub instance_messages: std::vec::Vec<crate::model::instance::InstanceMessage>,

    /// Output only. Endpoint for the Discovery API.
    pub discovery_endpoint: std::string::String,

    /// The maintenance policy for the instance. If not provided,
    /// the maintenance event will be performed based on Memorystore
    /// internal rollout schedule.
    pub maintenance_policy: std::option::Option<crate::model::MaintenancePolicy>,

    /// Output only. Published maintenance schedule.
    pub maintenance_schedule: std::option::Option<crate::model::MaintenanceSchedule>,

    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_memcache_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_memcache_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_memcache_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 [authorized_network][crate::model::Instance::authorized_network].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_memcache_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 [zones][crate::model::Instance::zones].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_memcache_v1::model::Instance;
    /// let x = Instance::new().set_zones(["a", "b", "c"]);
    /// ```
    pub fn set_zones<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.zones = v.into_iter().map(|i| i.into()).collect();
        self
    }

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

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

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

    /// Sets the value of [memcache_version][crate::model::Instance::memcache_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_memcache_v1::model::Instance;
    /// use google_cloud_memcache_v1::model::MemcacheVersion;
    /// let x0 = Instance::new().set_memcache_version(MemcacheVersion::Memcache15);
    /// ```
    pub fn set_memcache_version<T: std::convert::Into<crate::model::MemcacheVersion>>(
        mut self,
        v: T,
    ) -> Self {
        self.memcache_version = v.into();
        self
    }

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

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

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

    /// Sets the value of [create_time][crate::model::Instance::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_memcache_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_memcache_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 [update_time][crate::model::Instance::update_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_memcache_v1::model::Instance;
    /// use wkt::Timestamp;
    /// let x = Instance::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::Instance::update_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_memcache_v1::model::Instance;
    /// use wkt::Timestamp;
    /// let x = Instance::new().set_or_clear_update_time(Some(Timestamp::default()/* use setters */));
    /// let x = Instance::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 [state][crate::model::Instance::state].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_memcache_v1::model::Instance;
    /// use google_cloud_memcache_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 [memcache_full_version][crate::model::Instance::memcache_full_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_memcache_v1::model::Instance;
    /// let x = Instance::new().set_memcache_full_version("example");
    /// ```
    pub fn set_memcache_full_version<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.memcache_full_version = v.into();
        self
    }

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

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

    /// Sets the value of [maintenance_policy][crate::model::Instance::maintenance_policy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_memcache_v1::model::Instance;
    /// use google_cloud_memcache_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_memcache_v1::model::Instance;
    /// use google_cloud_memcache_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_memcache_v1::model::Instance;
    /// use google_cloud_memcache_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_memcache_v1::model::Instance;
    /// use google_cloud_memcache_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
    }
}

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

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

    /// Configuration for a Memcached Node.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct NodeConfig {
        /// Required. Number of cpus per Memcached node.
        pub cpu_count: i32,

        /// Required. Memory size in MiB for each Memcached node.
        pub memory_size_mb: i32,

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

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

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

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

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

    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct Node {
        /// Output only. Identifier of the Memcached node. The node id does not
        /// include project or location like the Memcached instance name.
        pub node_id: std::string::String,

        /// Output only. Location (GCP Zone) for the Memcached node.
        pub zone: std::string::String,

        /// Output only. Current state of the Memcached node.
        pub state: crate::model::instance::node::State,

        /// Output only. Hostname or IP address of the Memcached node used by the
        /// clients to connect to the Memcached server on this node.
        pub host: std::string::String,

        /// Output only. The port number of the Memcached server on this node.
        pub port: i32,

        /// User defined parameters currently applied to the node.
        pub parameters: std::option::Option<crate::model::MemcacheParameters>,

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

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

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

        /// Sets the value of [zone][crate::model::instance::Node::zone].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_memcache_v1::model::instance::Node;
        /// let x = Node::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
        }

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

        /// Sets the value of [host][crate::model::instance::Node::host].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_memcache_v1::model::instance::Node;
        /// let x = Node::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::Node::port].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_memcache_v1::model::instance::Node;
        /// let x = Node::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 [parameters][crate::model::instance::Node::parameters].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_memcache_v1::model::instance::Node;
        /// use google_cloud_memcache_v1::model::MemcacheParameters;
        /// let x = Node::new().set_parameters(MemcacheParameters::default()/* use setters */);
        /// ```
        pub fn set_parameters<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::model::MemcacheParameters>,
        {
            self.parameters = std::option::Option::Some(v.into());
            self
        }

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

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

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

        /// Different states of a Memcached node.
        ///
        /// # 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 {
            /// Node state is not set.
            Unspecified,
            /// Node is being created.
            Creating,
            /// Node has been created and ready to be used.
            Ready,
            /// Node is being deleted.
            Deleting,
            /// Node is being updated.
            Updating,
            /// 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::Deleting => std::option::Option::Some(3),
                    Self::Updating => std::option::Option::Some(4),
                    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::Deleting => std::option::Option::Some("DELETING"),
                    Self::Updating => std::option::Option::Some("UPDATING"),
                    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::Deleting,
                    4 => Self::Updating,
                    _ => 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,
                    "DELETING" => Self::Deleting,
                    "UPDATING" => Self::Updating,
                    _ => 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::Deleting => serializer.serialize_i32(3),
                    Self::Updating => serializer.serialize_i32(4),
                    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.memcache.v1.Instance.Node.State",
                ))
            }
        }
    }

    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct InstanceMessage {
        /// A code that correspond to one type of user-facing message.
        pub code: crate::model::instance::instance_message::Code,

        /// Message on memcached instance which will be exposed to users.
        pub message: std::string::String,

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

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

        /// Sets the value of [code][crate::model::instance::InstanceMessage::code].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_memcache_v1::model::instance::InstanceMessage;
        /// use google_cloud_memcache_v1::model::instance::instance_message::Code;
        /// let x0 = InstanceMessage::new().set_code(Code::ZoneDistributionUnbalanced);
        /// ```
        pub fn set_code<T: std::convert::Into<crate::model::instance::instance_message::Code>>(
            mut self,
            v: T,
        ) -> Self {
            self.code = v.into();
            self
        }

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

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

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

        ///
        /// # 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 Code {
            /// Message Code not set.
            Unspecified,
            /// Memcached nodes are distributed unevenly.
            ZoneDistributionUnbalanced,
            /// If set, the enum was initialized with an unknown value.
            ///
            /// Applications can examine the value using [Code::value] or
            /// [Code::name].
            UnknownValue(code::UnknownValue),
        }

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

        impl Code {
            /// 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::ZoneDistributionUnbalanced => 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("CODE_UNSPECIFIED"),
                    Self::ZoneDistributionUnbalanced => {
                        std::option::Option::Some("ZONE_DISTRIBUTION_UNBALANCED")
                    }
                    Self::UnknownValue(u) => u.0.name(),
                }
            }
        }

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

        impl std::fmt::Display for Code {
            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 Code {
            fn from(value: i32) -> Self {
                match value {
                    0 => Self::Unspecified,
                    1 => Self::ZoneDistributionUnbalanced,
                    _ => Self::UnknownValue(code::UnknownValue(
                        wkt::internal::UnknownEnumValue::Integer(value),
                    )),
                }
            }
        }

        impl std::convert::From<&str> for Code {
            fn from(value: &str) -> Self {
                use std::string::ToString;
                match value {
                    "CODE_UNSPECIFIED" => Self::Unspecified,
                    "ZONE_DISTRIBUTION_UNBALANCED" => Self::ZoneDistributionUnbalanced,
                    _ => Self::UnknownValue(code::UnknownValue(
                        wkt::internal::UnknownEnumValue::String(value.to_string()),
                    )),
                }
            }
        }

        impl serde::ser::Serialize for Code {
            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::ZoneDistributionUnbalanced => serializer.serialize_i32(1),
                    Self::UnknownValue(u) => u.0.serialize(serializer),
                }
            }
        }

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

    /// Different states of a Memcached 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 {
        /// State not set.
        Unspecified,
        /// Memcached instance is being created.
        Creating,
        /// Memcached instance has been created and ready to be used.
        Ready,
        /// Memcached instance is updating configuration such as maintenance policy
        /// and schedule.
        Updating,
        /// Memcached instance is being deleted.
        Deleting,
        /// Memcached instance is going through maintenance, e.g. data plane rollout.
        PerformingMaintenance,
        /// 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::PerformingMaintenance => std::option::Option::Some(5),
                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::PerformingMaintenance => std::option::Option::Some("PERFORMING_MAINTENANCE"),
                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::PerformingMaintenance,
                _ => 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,
                "PERFORMING_MAINTENANCE" => Self::PerformingMaintenance,
                _ => 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::PerformingMaintenance => serializer.serialize_i32(5),
                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.memcache.v1.Instance.State",
            ))
        }
    }
}

/// Maintenance policy per 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 updated.
    pub update_time: std::option::Option<wkt::Timestamp>,

    /// 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,

    /// Required. Maintenance window that is applied to resources covered by this
    /// policy. Minimum 1. For the current version, the maximum number of
    /// weekly_maintenance_windows 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_memcache_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_memcache_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_memcache_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_memcache_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_memcache_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_memcache_v1::model::MaintenancePolicy;
    /// use google_cloud_memcache_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.memcache.v1.MaintenancePolicy"
    }
}

/// Time window specified for weekly operations.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct WeeklyMaintenanceWindow {
    /// Required. Allows to define schedule that runs specified day of the week.
    pub day: gtype::model::DayOfWeek,

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

    /// Required. Duration of the time window.
    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_memcache_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_memcache_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_memcache_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_memcache_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_memcache_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.memcache.v1.WeeklyMaintenanceWindow"
    }
}

/// Upcoming maintenance schedule.
#[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>,

    /// 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_memcache_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_memcache_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_memcache_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_memcache_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 [schedule_deadline_time][crate::model::MaintenanceSchedule::schedule_deadline_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_memcache_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_memcache_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.memcache.v1.MaintenanceSchedule"
    }
}

/// Request for [RescheduleMaintenance][google.cloud.memcache.v1.CloudMemcache.RescheduleMaintenance].
///
/// [google.cloud.memcache.v1.CloudMemcache.RescheduleMaintenance]: crate::client::CloudMemcache::reschedule_maintenance
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct RescheduleMaintenanceRequest {
    /// Required. Memcache instance resource name using the form:
    /// `projects/{project_id}/locations/{location_id}/instances/{instance_id}`
    /// where `location_id` refers to a GCP region.
    pub instance: 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,

    /// 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 [instance][crate::model::RescheduleMaintenanceRequest::instance].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_memcache_v1::model::RescheduleMaintenanceRequest;
    /// let x = RescheduleMaintenanceRequest::new().set_instance("example");
    /// ```
    pub fn set_instance<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.instance = v.into();
        self
    }

    /// Sets the value of [reschedule_type][crate::model::RescheduleMaintenanceRequest::reschedule_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_memcache_v1::model::RescheduleMaintenanceRequest;
    /// use google_cloud_memcache_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_memcache_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_memcache_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.memcache.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.memcache.v1.RescheduleMaintenanceRequest.RescheduleType",
            ))
        }
    }
}

/// Request for [ListInstances][google.cloud.memcache.v1.CloudMemcache.ListInstances].
///
/// [google.cloud.memcache.v1.CloudMemcache.ListInstances]: crate::client::CloudMemcache::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.memcache.v1.ListInstancesResponse.next_page_token]
    /// to determine if there are more instances left to be queried.
    ///
    /// [google.cloud.memcache.v1.ListInstancesResponse.next_page_token]: crate::model::ListInstancesResponse::next_page_token
    pub page_size: i32,

    /// The `next_page_token` value returned from a previous List request, if any.
    pub page_token: std::string::String,

    /// List filter. For example, exclude all Memcached instances with name as
    /// my-instance by specifying `"name != my-instance"`.
    pub filter: std::string::String,

    /// Sort results. Supported values are "name", "name desc" or "" (unsorted).
    pub order_by: 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_memcache_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_memcache_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_memcache_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
    }

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

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

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

/// Response for [ListInstances][google.cloud.memcache.v1.CloudMemcache.ListInstances].
///
/// [google.cloud.memcache.v1.CloudMemcache.ListInstances]: crate::client::CloudMemcache::list_instances
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListInstancesResponse {
    /// A list of Memcached 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.
    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_memcache_v1::model::ListInstancesResponse;
    /// use google_cloud_memcache_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_memcache_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_memcache_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.memcache.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.memcache.v1.CloudMemcache.GetInstance].
///
/// [google.cloud.memcache.v1.CloudMemcache.GetInstance]: crate::client::CloudMemcache::get_instance
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GetInstanceRequest {
    /// Required. Memcached instance resource name in the format:
    /// `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_memcache_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.memcache.v1.GetInstanceRequest"
    }
}

/// Request for [CreateInstance][google.cloud.memcache.v1.CloudMemcache.CreateInstance].
///
/// [google.cloud.memcache.v1.CloudMemcache.CreateInstance]: crate::client::CloudMemcache::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 Memcached instance in the user
    /// 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 user project / location.
    ///
    /// If any of the above are not met, the API raises an invalid argument error.
    pub instance_id: std::string::String,

    /// Required. A Memcached Instance
    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_memcache_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_memcache_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_memcache_v1::model::CreateInstanceRequest;
    /// use google_cloud_memcache_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_memcache_v1::model::CreateInstanceRequest;
    /// use google_cloud_memcache_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.memcache.v1.CreateInstanceRequest"
    }
}

/// Request for [UpdateInstance][google.cloud.memcache.v1.CloudMemcache.UpdateInstance].
///
/// [google.cloud.memcache.v1.CloudMemcache.UpdateInstance]: crate::client::CloudMemcache::update_instance
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct UpdateInstanceRequest {
    /// Required. Mask of fields to update.
    ///
    /// * `displayName`
    pub update_mask: std::option::Option<wkt::FieldMask>,

    /// Required. A Memcached Instance.
    /// 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_memcache_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_memcache_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_memcache_v1::model::UpdateInstanceRequest;
    /// use google_cloud_memcache_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_memcache_v1::model::UpdateInstanceRequest;
    /// use google_cloud_memcache_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.memcache.v1.UpdateInstanceRequest"
    }
}

/// Request for [DeleteInstance][google.cloud.memcache.v1.CloudMemcache.DeleteInstance].
///
/// [google.cloud.memcache.v1.CloudMemcache.DeleteInstance]: crate::client::CloudMemcache::delete_instance
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DeleteInstanceRequest {
    /// Required. Memcached instance resource name in the format:
    /// `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_memcache_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.memcache.v1.DeleteInstanceRequest"
    }
}

/// Request for [ApplyParameters][google.cloud.memcache.v1.CloudMemcache.ApplyParameters].
///
/// [google.cloud.memcache.v1.CloudMemcache.ApplyParameters]: crate::client::CloudMemcache::apply_parameters
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ApplyParametersRequest {
    /// Required. Resource name of the Memcached instance for which parameter group updates
    /// should be applied.
    pub name: std::string::String,

    /// Nodes to which the instance-level parameter group is applied.
    pub node_ids: std::vec::Vec<std::string::String>,

    /// Whether to apply instance-level parameter group to all nodes. If set to
    /// true, users are restricted from specifying individual nodes, and
    /// `ApplyParameters` updates all nodes within the instance.
    pub apply_all: bool,

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

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

    /// Sets the value of [name][crate::model::ApplyParametersRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_memcache_v1::model::ApplyParametersRequest;
    /// let x = ApplyParametersRequest::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 [node_ids][crate::model::ApplyParametersRequest::node_ids].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_memcache_v1::model::ApplyParametersRequest;
    /// let x = ApplyParametersRequest::new().set_node_ids(["a", "b", "c"]);
    /// ```
    pub fn set_node_ids<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.node_ids = v.into_iter().map(|i| i.into()).collect();
        self
    }

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

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

/// Request for [UpdateParameters][google.cloud.memcache.v1.CloudMemcache.UpdateParameters].
///
/// [google.cloud.memcache.v1.CloudMemcache.UpdateParameters]: crate::client::CloudMemcache::update_parameters
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct UpdateParametersRequest {
    /// Required. Resource name of the Memcached instance for which the parameters should be
    /// updated.
    pub name: std::string::String,

    /// Required. Mask of fields to update.
    pub update_mask: std::option::Option<wkt::FieldMask>,

    /// The parameters to apply to the instance.
    pub parameters: std::option::Option<crate::model::MemcacheParameters>,

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

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

    /// Sets the value of [name][crate::model::UpdateParametersRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_memcache_v1::model::UpdateParametersRequest;
    /// let x = UpdateParametersRequest::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 [update_mask][crate::model::UpdateParametersRequest::update_mask].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_memcache_v1::model::UpdateParametersRequest;
    /// use wkt::FieldMask;
    /// let x = UpdateParametersRequest::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::UpdateParametersRequest::update_mask].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_memcache_v1::model::UpdateParametersRequest;
    /// use wkt::FieldMask;
    /// let x = UpdateParametersRequest::new().set_or_clear_update_mask(Some(FieldMask::default()/* use setters */));
    /// let x = UpdateParametersRequest::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 [parameters][crate::model::UpdateParametersRequest::parameters].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_memcache_v1::model::UpdateParametersRequest;
    /// use google_cloud_memcache_v1::model::MemcacheParameters;
    /// let x = UpdateParametersRequest::new().set_parameters(MemcacheParameters::default()/* use setters */);
    /// ```
    pub fn set_parameters<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::MemcacheParameters>,
    {
        self.parameters = std::option::Option::Some(v.into());
        self
    }

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

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

#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct MemcacheParameters {
    /// Output only. The unique ID associated with this set of parameters. Users
    /// can use this id to determine if the parameters associated with the instance
    /// differ from the parameters associated with the nodes. A discrepancy between
    /// parameter ids can inform users that they may need to take action to apply
    /// parameters on nodes.
    pub id: std::string::String,

    /// User defined set of parameters to use in the memcached process.
    pub params: std::collections::HashMap<std::string::String, std::string::String>,

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

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

    /// Sets the value of [id][crate::model::MemcacheParameters::id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_memcache_v1::model::MemcacheParameters;
    /// let x = MemcacheParameters::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 [params][crate::model::MemcacheParameters::params].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_memcache_v1::model::MemcacheParameters;
    /// let x = MemcacheParameters::new().set_params([
    ///     ("key0", "abc"),
    ///     ("key1", "xyz"),
    /// ]);
    /// ```
    pub fn set_params<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.params = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }
}

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

/// Represents the metadata of a long-running operation.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct OperationMetadata {
    /// Output only. Time when the operation was created.
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. Time when the operation finished running.
    pub end_time: std::option::Option<wkt::Timestamp>,

    /// Output only. Server-defined resource path for the target of the operation.
    pub target: std::string::String,

    /// Output only. Name of the verb executed by the operation.
    pub verb: std::string::String,

    /// Output only. Human-readable status of the operation, if any.
    pub status_detail: std::string::String,

    /// Output only. Identifies whether the user has requested cancellation
    /// of the operation. Operations that have successfully been cancelled
    /// have [Operation.error][] value with a [google.rpc.Status.code][google.rpc.Status.code] of 1,
    /// corresponding to `Code.CANCELLED`.
    ///
    /// [google.rpc.Status.code]: rpc::model::Status::code
    pub cancel_requested: bool,

    /// Output only. API version used to start the operation.
    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_memcache_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_memcache_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_memcache_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_memcache_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_memcache_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_memcache_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_memcache_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_memcache_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_memcache_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.memcache.v1.OperationMetadata"
    }
}

/// Metadata for the given [google.cloud.location.Location][google.cloud.location.Location].
///
/// [google.cloud.location.Location]: location::model::Location
#[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 the `zones` field when creating a Memcached 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_memcache_v1::model::LocationMetadata;
    /// use google_cloud_memcache_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.memcache.v1.LocationMetadata"
    }
}

#[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.memcache.v1.ZoneMetadata"
    }
}

/// Memcached versions supported by our service.
///
/// # 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 MemcacheVersion {
    Unspecified,
    /// Memcached 1.5 version.
    Memcache15,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [MemcacheVersion::value] or
    /// [MemcacheVersion::name].
    UnknownValue(memcache_version::UnknownValue),
}

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

impl MemcacheVersion {
    /// 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::Memcache15 => 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("MEMCACHE_VERSION_UNSPECIFIED"),
            Self::Memcache15 => std::option::Option::Some("MEMCACHE_1_5"),
            Self::UnknownValue(u) => u.0.name(),
        }
    }
}

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

impl std::fmt::Display for MemcacheVersion {
    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 MemcacheVersion {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::Unspecified,
            1 => Self::Memcache15,
            _ => Self::UnknownValue(memcache_version::UnknownValue(
                wkt::internal::UnknownEnumValue::Integer(value),
            )),
        }
    }
}

impl std::convert::From<&str> for MemcacheVersion {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "MEMCACHE_VERSION_UNSPECIFIED" => Self::Unspecified,
            "MEMCACHE_1_5" => Self::Memcache15,
            _ => Self::UnknownValue(memcache_version::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

impl serde::ser::Serialize for MemcacheVersion {
    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::Memcache15 => serializer.serialize_i32(1),
            Self::UnknownValue(u) => u.0.serialize(serializer),
        }
    }
}

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