google-cloud-ftp-v1 1.0.0

// Copyright 2026 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::bare_urls)]
#![allow(rustdoc::broken_intra_doc_links)]
#![allow(rustdoc::invalid_html_tags)]
#![allow(rustdoc::redundant_explicit_links)]
#![no_implicit_prelude]
extern crate async_trait;
extern crate bytes;
extern crate gaxi;
extern crate google_cloud_gax;
extern crate google_cloud_location;
extern crate google_cloud_longrunning;
extern crate google_cloud_lro;
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;

/// Configuration for external server.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ExternalServerConfig {
    /// Output only. IP address of the LB via which clients will connect.
    pub ip_address: std::string::String,

    /// Optional. List of CIDR blocks that are allowed to access the Server.
    /// A CIDR range consists of an IP Address and a prefix length to construct the
    /// subnet mask. By default, the prefix length is 32 (i.e. matches a single IP
    /// address). For now, only IPV4 addresses are supported.
    /// Examples: "203.0.113.0/24" -
    /// matches with the IP addresses in the range 203.0.113.0 - 203.0.113.255.
    /// "0.0.0.0/0" - matches against any IP address.
    /// This field must contain at least one entry if the access type is EXTERNAL.
    /// The number of allowed CIDR blocks cannot exceed 500.
    /// Example: 192.168.0.0/16
    pub allowed_cidr_blocks: std::vec::Vec<std::string::String>,

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

impl ExternalServerConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

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

/// Configuration for private server accessible via PSC.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct InternalServerConfig {
    /// Output only. The resource name of the service attachment.
    /// Format:
    /// `projects/{project}/regions/{region}/serviceAttachments/{service_attachment}`
    pub service_attachment: std::string::String,

    /// Required. A list of projects that are permitted to connect.
    /// At least one project is required in the allow list.
    pub consumer_accept_list: std::vec::Vec<crate::model::internal_server_config::AllowedConsumer>,

    /// Optional. A list of projects that are denied connection.
    /// Format: "projects/sample_project_id" or "projects/1234567890"
    /// Projects in this list will be denied access, even if they are included in
    /// the `allow_list`. If this list is empty, no projects are explicitly
    /// rejected.
    pub consumer_reject_list: std::vec::Vec<crate::model::internal_server_config::DeniedConsumer>,

    /// Output only. Details of endpoints created by the customer.
    pub psc_endpoints: std::vec::Vec<crate::model::internal_server_config::PscEndpoint>,

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

impl InternalServerConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

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

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

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

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

    /// A consumer project or network that is permitted to connect to the server
    /// via PSC.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct AllowedConsumer {
        /// Required. The connection limit for the consumer.
        /// Value must be greater than 0.
        pub connection_limit: i64,

        /// Required. Specifies the type of consumer.
        pub consumer_type: std::option::Option<
            crate::model::internal_server_config::allowed_consumer::ConsumerType,
        >,

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

    impl AllowedConsumer {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [connection_limit][crate::model::internal_server_config::AllowedConsumer::connection_limit].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_ftp_v1::model::internal_server_config::AllowedConsumer;
        /// let x = AllowedConsumer::new().set_connection_limit(42);
        /// ```
        pub fn set_connection_limit<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
            self.connection_limit = v.into();
            self
        }

        /// Sets the value of [consumer_type][crate::model::internal_server_config::AllowedConsumer::consumer_type].
        ///
        /// Note that all the setters affecting `consumer_type` are mutually
        /// exclusive.
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_ftp_v1::model::internal_server_config::AllowedConsumer;
        /// use google_cloud_ftp_v1::model::internal_server_config::allowed_consumer::ConsumerType;
        /// let x = AllowedConsumer::new().set_consumer_type(Some(ConsumerType::Project("example".to_string())));
        /// ```
        pub fn set_consumer_type<
            T: std::convert::Into<
                    std::option::Option<
                        crate::model::internal_server_config::allowed_consumer::ConsumerType,
                    >,
                >,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.consumer_type = v.into();
            self
        }

        /// The value of [consumer_type][crate::model::internal_server_config::AllowedConsumer::consumer_type]
        /// if it holds a `Project`, `None` if the field is not set or
        /// holds a different branch.
        pub fn project(&self) -> std::option::Option<&std::string::String> {
            #[allow(unreachable_patterns)]
            self.consumer_type.as_ref().and_then(|v| match v {
                crate::model::internal_server_config::allowed_consumer::ConsumerType::Project(
                    v,
                ) => std::option::Option::Some(v),
                _ => std::option::Option::None,
            })
        }

        /// Sets the value of [consumer_type][crate::model::internal_server_config::AllowedConsumer::consumer_type]
        /// to hold a `Project`.
        ///
        /// Note that all the setters affecting `consumer_type` are
        /// mutually exclusive.
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_ftp_v1::model::internal_server_config::AllowedConsumer;
        /// let x = AllowedConsumer::new().set_project("example");
        /// assert!(x.project().is_some());
        /// ```
        pub fn set_project<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.consumer_type = std::option::Option::Some(
                crate::model::internal_server_config::allowed_consumer::ConsumerType::Project(
                    v.into(),
                ),
            );
            self
        }
    }

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

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

        /// Required. Specifies the type of consumer.
        #[derive(Clone, Debug, PartialEq)]
        #[non_exhaustive]
        pub enum ConsumerType {
            /// The project ID or number of the consumer project.
            /// Must be in the format: `projects/{project}`.
            Project(std::string::String),
        }
    }

    /// A consumer project or network that is denied to connect to the server via
    /// PSC.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct DeniedConsumer {
        /// Required. Specifies the type of consumer.
        pub consumer_type: std::option::Option<
            crate::model::internal_server_config::denied_consumer::ConsumerType,
        >,

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

    impl DeniedConsumer {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [consumer_type][crate::model::internal_server_config::DeniedConsumer::consumer_type].
        ///
        /// Note that all the setters affecting `consumer_type` are mutually
        /// exclusive.
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_ftp_v1::model::internal_server_config::DeniedConsumer;
        /// use google_cloud_ftp_v1::model::internal_server_config::denied_consumer::ConsumerType;
        /// let x = DeniedConsumer::new().set_consumer_type(Some(ConsumerType::Project("example".to_string())));
        /// ```
        pub fn set_consumer_type<
            T: std::convert::Into<
                    std::option::Option<
                        crate::model::internal_server_config::denied_consumer::ConsumerType,
                    >,
                >,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.consumer_type = v.into();
            self
        }

        /// The value of [consumer_type][crate::model::internal_server_config::DeniedConsumer::consumer_type]
        /// if it holds a `Project`, `None` if the field is not set or
        /// holds a different branch.
        pub fn project(&self) -> std::option::Option<&std::string::String> {
            #[allow(unreachable_patterns)]
            self.consumer_type.as_ref().and_then(|v| match v {
                crate::model::internal_server_config::denied_consumer::ConsumerType::Project(v) => {
                    std::option::Option::Some(v)
                }
                _ => std::option::Option::None,
            })
        }

        /// Sets the value of [consumer_type][crate::model::internal_server_config::DeniedConsumer::consumer_type]
        /// to hold a `Project`.
        ///
        /// Note that all the setters affecting `consumer_type` are
        /// mutually exclusive.
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_ftp_v1::model::internal_server_config::DeniedConsumer;
        /// let x = DeniedConsumer::new().set_project("example");
        /// assert!(x.project().is_some());
        /// ```
        pub fn set_project<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.consumer_type = std::option::Option::Some(
                crate::model::internal_server_config::denied_consumer::ConsumerType::Project(
                    v.into(),
                ),
            );
            self
        }
    }

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

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

        /// Required. Specifies the type of consumer.
        #[derive(Clone, Debug, PartialEq)]
        #[non_exhaustive]
        pub enum ConsumerType {
            /// The project ID or number of the consumer project.
            /// Must be in the format: `projects/{project}`.
            Project(std::string::String),
        }
    }

    /// Details of PSC endpoint created by customer.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct PscEndpoint {
        /// Output only. This is a Resource name for Private Service Connect
        /// endpoint. Format:
        /// `projects/{project}/regions/{region}/forwardingRules/{forwarding_rule}`
        pub endpoint: std::string::String,

        /// Output only. The consumer network.
        /// Format: `projects/{project}/locations/{location}/networks/{network}`
        pub network: std::string::String,

        /// Output only. The status of the connected endpoint.
        pub status: std::string::String,

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

    impl PscEndpoint {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

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

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

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

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

/// Represents credentials of an FTP Server.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ServerCredential {
    /// Output only. The fingerprint is a hash of the public key, and is displayed
    /// when clients access the server for the first time to verify the server's
    /// identity.
    pub fingerprint: std::string::String,

    /// Output only. Asymmetric algorithm used by the public key.
    /// Possible values (can be expanded in future):
    ///
    /// - ssh-ed25519
    pub asymmetric_algorithm: std::string::String,

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

impl ServerCredential {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

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

/// Message describing Server object
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Server {
    /// Identifier. name of resource
    pub name: std::string::String,

    /// Output only. [Output only] Create time stamp
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. [Output only] Update time stamp
    pub update_time: std::option::Option<wkt::Timestamp>,

    /// Optional. Labels as key value pairs
    pub labels: std::collections::HashMap<std::string::String, std::string::String>,

    /// Optional. Display name of the Server
    pub display_name: std::string::String,

    /// Required. The access type of the Server.
    pub access_type: crate::model::server::AccessType,

    /// Output only. The state of the server.
    pub state: crate::model::server::State,

    /// Output only. Credentials of the FTP Server.
    pub google_managed_server_credential: std::option::Option<crate::model::ServerCredential>,

    /// Output only. Service agent used to access the customer bucket.
    pub service_agent: std::string::String,

    /// Configuration for server access.
    /// If this is set, it must match the value in the `access_type` field.
    pub access_config: std::option::Option<crate::model::server::AccessConfig>,

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

impl Server {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::Server::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::Server;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// # let server_id = "server_id";
    /// let x = Server::new().set_name(format!("projects/{project_id}/locations/{location_id}/servers/{server_id}"));
    /// ```
    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 [create_time][crate::model::Server::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::Server;
    /// use wkt::Timestamp;
    /// let x = Server::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::Server::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::Server;
    /// use wkt::Timestamp;
    /// let x = Server::new().set_or_clear_create_time(Some(Timestamp::default()/* use setters */));
    /// let x = Server::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::Server::update_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::Server;
    /// use wkt::Timestamp;
    /// let x = Server::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::Server::update_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::Server;
    /// use wkt::Timestamp;
    /// let x = Server::new().set_or_clear_update_time(Some(Timestamp::default()/* use setters */));
    /// let x = Server::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 [labels][crate::model::Server::labels].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::Server;
    /// let x = Server::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 [display_name][crate::model::Server::display_name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::Server;
    /// let x = Server::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 [access_type][crate::model::Server::access_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::Server;
    /// use google_cloud_ftp_v1::model::server::AccessType;
    /// let x0 = Server::new().set_access_type(AccessType::External);
    /// let x1 = Server::new().set_access_type(AccessType::Internal);
    /// ```
    pub fn set_access_type<T: std::convert::Into<crate::model::server::AccessType>>(
        mut self,
        v: T,
    ) -> Self {
        self.access_type = v.into();
        self
    }

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

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

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

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

    /// Sets the value of [access_config][crate::model::Server::access_config].
    ///
    /// Note that all the setters affecting `access_config` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::Server;
    /// use google_cloud_ftp_v1::model::ExternalServerConfig;
    /// let x = Server::new().set_access_config(Some(
    ///     google_cloud_ftp_v1::model::server::AccessConfig::ExternalConfig(ExternalServerConfig::default().into())));
    /// ```
    pub fn set_access_config<
        T: std::convert::Into<std::option::Option<crate::model::server::AccessConfig>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.access_config = v.into();
        self
    }

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

    /// Sets the value of [access_config][crate::model::Server::access_config]
    /// to hold a `ExternalConfig`.
    ///
    /// Note that all the setters affecting `access_config` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::Server;
    /// use google_cloud_ftp_v1::model::ExternalServerConfig;
    /// let x = Server::new().set_external_config(ExternalServerConfig::default()/* use setters */);
    /// assert!(x.external_config().is_some());
    /// assert!(x.internal_config().is_none());
    /// ```
    pub fn set_external_config<
        T: std::convert::Into<std::boxed::Box<crate::model::ExternalServerConfig>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.access_config =
            std::option::Option::Some(crate::model::server::AccessConfig::ExternalConfig(v.into()));
        self
    }

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

    /// Sets the value of [access_config][crate::model::Server::access_config]
    /// to hold a `InternalConfig`.
    ///
    /// Note that all the setters affecting `access_config` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::Server;
    /// use google_cloud_ftp_v1::model::InternalServerConfig;
    /// let x = Server::new().set_internal_config(InternalServerConfig::default()/* use setters */);
    /// assert!(x.internal_config().is_some());
    /// assert!(x.external_config().is_none());
    /// ```
    pub fn set_internal_config<
        T: std::convert::Into<std::boxed::Box<crate::model::InternalServerConfig>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.access_config =
            std::option::Option::Some(crate::model::server::AccessConfig::InternalConfig(v.into()));
        self
    }
}

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

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

    /// The access type of the Server.
    ///
    /// # 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://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum AccessType {
        /// Default value. This value is unused.
        Unspecified,
        /// Server is assigned a public IP.
        External,
        /// Server is assigned an internal IP.
        Internal,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [AccessType::value] or
        /// [AccessType::name].
        UnknownValue(access_type::UnknownValue),
    }

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

    impl AccessType {
        /// 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::External => std::option::Option::Some(1),
                Self::Internal => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

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

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

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

    impl std::convert::From<&str> for AccessType {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "ACCESS_TYPE_UNSPECIFIED" => Self::Unspecified,
                "EXTERNAL" => Self::External,
                "INTERNAL" => Self::Internal,
                _ => Self::UnknownValue(access_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

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

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

    /// Tracks Server status.
    ///
    /// # 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://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum State {
        /// Default value. This value is unused.
        Unspecified,
        /// Server is being created.
        Creating,
        /// Server is starting.
        Starting,
        /// Server is ready to be used.
        Active,
        /// Server is stopping.
        Stopping,
        /// Server is stopped.
        Stopped,
        /// Server is being deleted.
        Deleting,
        /// Server is in error state.
        Error,
        /// Server 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::Starting => std::option::Option::Some(2),
                Self::Active => std::option::Option::Some(3),
                Self::Stopping => std::option::Option::Some(4),
                Self::Stopped => std::option::Option::Some(5),
                Self::Deleting => std::option::Option::Some(6),
                Self::Error => std::option::Option::Some(7),
                Self::Updating => std::option::Option::Some(8),
                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::Starting => std::option::Option::Some("STARTING"),
                Self::Active => std::option::Option::Some("ACTIVE"),
                Self::Stopping => std::option::Option::Some("STOPPING"),
                Self::Stopped => std::option::Option::Some("STOPPED"),
                Self::Deleting => std::option::Option::Some("DELETING"),
                Self::Error => std::option::Option::Some("ERROR"),
                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::Starting,
                3 => Self::Active,
                4 => Self::Stopping,
                5 => Self::Stopped,
                6 => Self::Deleting,
                7 => Self::Error,
                8 => 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,
                "STARTING" => Self::Starting,
                "ACTIVE" => Self::Active,
                "STOPPING" => Self::Stopping,
                "STOPPED" => Self::Stopped,
                "DELETING" => Self::Deleting,
                "ERROR" => Self::Error,
                "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::Starting => serializer.serialize_i32(2),
                Self::Active => serializer.serialize_i32(3),
                Self::Stopping => serializer.serialize_i32(4),
                Self::Stopped => serializer.serialize_i32(5),
                Self::Deleting => serializer.serialize_i32(6),
                Self::Error => serializer.serialize_i32(7),
                Self::Updating => serializer.serialize_i32(8),
                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.ftp.v1.Server.State",
            ))
        }
    }

    /// Configuration for server access.
    /// If this is set, it must match the value in the `access_type` field.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum AccessConfig {
        /// Configuration for external access.
        ExternalConfig(std::boxed::Box<crate::model::ExternalServerConfig>),
        /// Configuration for internal access.
        InternalConfig(std::boxed::Box<crate::model::InternalServerConfig>),
    }
}

/// Message for requesting list of Servers
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListServersRequest {
    /// Required. Parent value for ListServersRequest
    pub parent: std::string::String,

    /// Optional. Requested page size. Server may return fewer items than
    /// requested. If unspecified, server will pick an appropriate default.
    pub page_size: i32,

    /// Optional. A token identifying a page of results the server should return.
    pub page_token: std::string::String,

    /// Optional. Filtering results
    pub filter: std::string::String,

    /// Optional. Hint for how to order the results
    pub order_by: std::string::String,

    /// Optional. The view of the Server resource to return.
    pub view: crate::model::ServerView,

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

impl ListServersRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::ListServersRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::ListServersRequest;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// let x = ListServersRequest::new().set_parent(format!("projects/{project_id}/locations/{location_id}"));
    /// ```
    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::ListServersRequest::page_size].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::ListServersRequest;
    /// let x = ListServersRequest::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::ListServersRequest::page_token].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::ListServersRequest;
    /// let x = ListServersRequest::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::ListServersRequest::filter].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::ListServersRequest;
    /// let x = ListServersRequest::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::ListServersRequest::order_by].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::ListServersRequest;
    /// let x = ListServersRequest::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
    }

    /// Sets the value of [view][crate::model::ListServersRequest::view].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::ListServersRequest;
    /// use google_cloud_ftp_v1::model::ServerView;
    /// let x0 = ListServersRequest::new().set_view(ServerView::Basic);
    /// let x1 = ListServersRequest::new().set_view(ServerView::Full);
    /// ```
    pub fn set_view<T: std::convert::Into<crate::model::ServerView>>(mut self, v: T) -> Self {
        self.view = v.into();
        self
    }
}

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

/// Message for response to listing Servers
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListServersResponse {
    /// The list of Server
    pub servers: std::vec::Vec<crate::model::Server>,

    /// A token identifying a page of results the server should return.
    pub next_page_token: std::string::String,

    /// Unordered list. 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 ListServersResponse {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

    /// Sets the value of [next_page_token][crate::model::ListServersResponse::next_page_token].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::ListServersResponse;
    /// let x = ListServersResponse::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::ListServersResponse::unreachable].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::ListServersResponse;
    /// let x = ListServersResponse::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 ListServersResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.ftp.v1.ListServersResponse"
    }
}

#[doc(hidden)]
impl google_cloud_gax::paginator::internal::PageableResponse for ListServersResponse {
    type PageItem = crate::model::Server;

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

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

/// Message for getting a Server
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GetServerRequest {
    /// Required. Name of the resource
    pub name: std::string::String,

    /// Optional. The view of the Server resource to return.
    pub view: crate::model::ServerView,

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

impl GetServerRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::GetServerRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::GetServerRequest;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// # let server_id = "server_id";
    /// let x = GetServerRequest::new().set_name(format!("projects/{project_id}/locations/{location_id}/servers/{server_id}"));
    /// ```
    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 [view][crate::model::GetServerRequest::view].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::GetServerRequest;
    /// use google_cloud_ftp_v1::model::ServerView;
    /// let x0 = GetServerRequest::new().set_view(ServerView::Basic);
    /// let x1 = GetServerRequest::new().set_view(ServerView::Full);
    /// ```
    pub fn set_view<T: std::convert::Into<crate::model::ServerView>>(mut self, v: T) -> Self {
        self.view = v.into();
        self
    }
}

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

/// Message for creating a Server
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CreateServerRequest {
    /// Required. Value for parent.
    pub parent: std::string::String,

    /// Required. A unique ID for the server. Must start with a lowercase letter,
    /// and end with a lowercase letter or number. Can contain lowercase letters,
    /// numbers, and hyphens. Maximum length is 30 characters.
    pub server_id: std::string::String,

    /// Required. The resource being created
    pub server: std::option::Option<crate::model::Server>,

    /// Optional. An optional request ID to identify requests. Specify a unique
    /// request ID so that if you must retry your request, the server will know to
    /// ignore the request if it has already been completed. The server will
    /// guarantee that for at least 60 minutes since the first request.
    ///
    /// For example, consider a situation where you make an initial request and the
    /// request times out. If you make the request again with the same request
    /// ID, the server can check if original operation with the same request ID
    /// was received, and if so, will ignore the second request. This prevents
    /// clients from accidentally creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID with the exception that zero UUID is
    /// not supported (00000000-0000-0000-0000-000000000000).
    pub request_id: std::string::String,

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

impl CreateServerRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::CreateServerRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::CreateServerRequest;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// let x = CreateServerRequest::new().set_parent(format!("projects/{project_id}/locations/{location_id}"));
    /// ```
    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 [server_id][crate::model::CreateServerRequest::server_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::CreateServerRequest;
    /// let x = CreateServerRequest::new().set_server_id("example");
    /// ```
    pub fn set_server_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.server_id = v.into();
        self
    }

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

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

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

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

/// Message for updating a Server
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct UpdateServerRequest {
    /// Optional. Field mask is used to specify the fields to be overwritten in the
    /// Server resource by the update.
    /// The fields specified in the update_mask are relative to the resource, not
    /// the full request. A field will be overwritten if it is in the mask. If the
    /// user does not provide a mask then all fields present in the request will be
    /// overwritten.
    pub update_mask: std::option::Option<wkt::FieldMask>,

    /// Required. The resource being updated
    pub server: std::option::Option<crate::model::Server>,

    /// Optional. An optional request ID to identify requests. Specify a unique
    /// request ID so that if you must retry your request, the server will know to
    /// ignore the request if it has already been completed. The server will
    /// guarantee that for at least 60 minutes since the first request.
    ///
    /// For example, consider a situation where you make an initial request and the
    /// request times out. If you make the request again with the same request
    /// ID, the server can check if original operation with the same request ID
    /// was received, and if so, will ignore the second request. This prevents
    /// clients from accidentally creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID with the exception that zero UUID is
    /// not supported (00000000-0000-0000-0000-000000000000).
    pub request_id: std::string::String,

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

impl UpdateServerRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

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

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

/// Message for deleting a Server
/// Note: Cascading delete is not supported. Any nested User resources
/// under this Server must be deleted before the Server itself can be deleted.
/// Attempting to delete a Server with active User resources will result in an
/// error.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DeleteServerRequest {
    /// Required. Name of the resource
    pub name: std::string::String,

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

impl DeleteServerRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::DeleteServerRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::DeleteServerRequest;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// # let server_id = "server_id";
    /// let x = DeleteServerRequest::new().set_name(format!("projects/{project_id}/locations/{location_id}/servers/{server_id}"));
    /// ```
    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 DeleteServerRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.ftp.v1.DeleteServerRequest"
    }
}

/// Mapping of backing Cloud Storage path to the directory where the user lands
/// in the SFTP server. If directory is not specified, it'll default to '/'.
///
/// Eg 1 -
/// (bucket_name: bucket, bucket_prefix: path1/path2, directory:
/// /abc/def/username)
///
/// The user will land at /abcd/def/username, and the view there will match that
/// of /bucket/path1/path2. The user will not be aware of Cloud Storage prefix
/// '/bucket/path1' and there will be no such directory in the view.
///
/// Eg 2 -
/// (bucket_name: bucket, bucket_prefix: path1/path2, directory: '')
///
/// The user will land at '/', and the view there will match
/// that of /bucket/path1/path2. The user will not be aware of Cloud Storage
/// prefix '/bucket/path1/path2' and there will be no such directory in the view.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct StorageDirectoryMapping {
    /// Required. Name of the bucket.
    pub bucket: std::string::String,

    /// Optional. Prefix inside the bucket.
    pub bucket_prefix: std::string::String,

    /// Required. Directory where the user lands in the SFTP server.
    pub directory: std::string::String,

    /// Required. Permission to the bucket.
    pub permission: crate::model::storage_directory_mapping::Permission,

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

impl StorageDirectoryMapping {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

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

    /// Sets the value of [permission][crate::model::StorageDirectoryMapping::permission].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::StorageDirectoryMapping;
    /// use google_cloud_ftp_v1::model::storage_directory_mapping::Permission;
    /// let x0 = StorageDirectoryMapping::new().set_permission(Permission::ReadOnly);
    /// let x1 = StorageDirectoryMapping::new().set_permission(Permission::ReadWrite);
    /// ```
    pub fn set_permission<
        T: std::convert::Into<crate::model::storage_directory_mapping::Permission>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.permission = v.into();
        self
    }
}

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

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

    /// Tracks read/write access to the bucket.
    ///
    /// # 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://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Permission {
        /// Permission unspecified.
        Unspecified,
        /// Read only permission.
        ReadOnly,
        /// Read write permission.
        ReadWrite,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Permission::value] or
        /// [Permission::name].
        UnknownValue(permission::UnknownValue),
    }

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

    impl Permission {
        /// 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::ReadOnly => std::option::Option::Some(1),
                Self::ReadWrite => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

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

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

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

    impl std::convert::From<&str> for Permission {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "PERMISSION_UNSPECIFIED" => Self::Unspecified,
                "READ_ONLY" => Self::ReadOnly,
                "READ_WRITE" => Self::ReadWrite,
                _ => Self::UnknownValue(permission::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

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

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

/// Message describing User object
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct User {
    /// Identifier. User-friendly name via which User will be identified.
    /// projects/{project}/locations/{location}/servers/{server}/users/{user}
    pub name: std::string::String,

    /// Output only. [Output only] Create time stamp
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. [Output only] Update time stamp
    pub update_time: std::option::Option<wkt::Timestamp>,

    /// Optional. Labels as key value pairs
    pub labels: std::collections::HashMap<std::string::String, std::string::String>,

    /// Output only. [Output only] The username of the user.
    pub username: std::string::String,

    /// Required. Service account in customer project attached to this SFTP User.
    pub customer_service_account: std::string::String,

    /// Output only. Tracks user creation.
    pub state: crate::model::user::State,

    /// Required. User credential for the user.
    /// The maximum number of user credentials is 10.
    pub user_credentials: std::vec::Vec<crate::model::UserCredential>,

    /// Required. Mapping of Cloud Storage buckets to directories where the user
    /// will land in the SFTP server.
    pub storage_directory_mappings: std::vec::Vec<crate::model::StorageDirectoryMapping>,

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

impl User {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::User::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::User;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// # let server_id = "server_id";
    /// # let user_id = "user_id";
    /// let x = User::new().set_name(format!("projects/{project_id}/locations/{location_id}/servers/{server_id}/users/{user_id}"));
    /// ```
    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 [create_time][crate::model::User::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::User;
    /// use wkt::Timestamp;
    /// let x = User::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::User::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::User;
    /// use wkt::Timestamp;
    /// let x = User::new().set_or_clear_create_time(Some(Timestamp::default()/* use setters */));
    /// let x = User::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::User::update_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::User;
    /// use wkt::Timestamp;
    /// let x = User::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::User::update_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::User;
    /// use wkt::Timestamp;
    /// let x = User::new().set_or_clear_update_time(Some(Timestamp::default()/* use setters */));
    /// let x = User::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 [labels][crate::model::User::labels].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::User;
    /// let x = User::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 [username][crate::model::User::username].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::User;
    /// let x = User::new().set_username("example");
    /// ```
    pub fn set_username<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.username = v.into();
        self
    }

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

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

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

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

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

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

    /// Tracks user creation.
    ///
    /// # 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://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum State {
        /// State unspecified.
        Unspecified,
        /// User is being created.
        Creating,
        /// User is ready to be used.
        Active,
        /// User creation failed.
        Error,
        /// The resource is being updated.
        Updating,
        /// The resource is being deleted.
        Deleting,
        /// 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::Active => std::option::Option::Some(2),
                Self::Error => std::option::Option::Some(3),
                Self::Updating => std::option::Option::Some(4),
                Self::Deleting => 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::Active => std::option::Option::Some("ACTIVE"),
                Self::Error => std::option::Option::Some("ERROR"),
                Self::Updating => std::option::Option::Some("UPDATING"),
                Self::Deleting => std::option::Option::Some("DELETING"),
                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::Active,
                3 => Self::Error,
                4 => Self::Updating,
                5 => Self::Deleting,
                _ => 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,
                "ACTIVE" => Self::Active,
                "ERROR" => Self::Error,
                "UPDATING" => Self::Updating,
                "DELETING" => Self::Deleting,
                _ => 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::Active => serializer.serialize_i32(2),
                Self::Error => serializer.serialize_i32(3),
                Self::Updating => serializer.serialize_i32(4),
                Self::Deleting => 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.ftp.v1.User.State",
            ))
        }
    }
}

/// Message for requesting list of Users
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListUsersRequest {
    /// Required. Parent value for ListUsersRequest
    pub parent: std::string::String,

    /// Optional. Requested page size. User may return fewer items than requested.
    /// The maximum value is 1000; The default value is 50 if the field is omitted
    /// (or set to 0).
    pub page_size: i32,

    /// Optional. A token identifying a page of results the user should return.
    pub page_token: std::string::String,

    /// Optional. Filtering results
    pub filter: std::string::String,

    /// Optional. Hint for how to order the results
    pub order_by: std::string::String,

    /// Optional. The view of the User resource to return.
    pub view: crate::model::UserView,

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

impl ListUsersRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::ListUsersRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::ListUsersRequest;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// # let server_id = "server_id";
    /// let x = ListUsersRequest::new().set_parent(format!("projects/{project_id}/locations/{location_id}/servers/{server_id}"));
    /// ```
    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::ListUsersRequest::page_size].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::ListUsersRequest;
    /// let x = ListUsersRequest::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::ListUsersRequest::page_token].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::ListUsersRequest;
    /// let x = ListUsersRequest::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::ListUsersRequest::filter].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::ListUsersRequest;
    /// let x = ListUsersRequest::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::ListUsersRequest::order_by].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::ListUsersRequest;
    /// let x = ListUsersRequest::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
    }

    /// Sets the value of [view][crate::model::ListUsersRequest::view].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::ListUsersRequest;
    /// use google_cloud_ftp_v1::model::UserView;
    /// let x0 = ListUsersRequest::new().set_view(UserView::Basic);
    /// let x1 = ListUsersRequest::new().set_view(UserView::Full);
    /// ```
    pub fn set_view<T: std::convert::Into<crate::model::UserView>>(mut self, v: T) -> Self {
        self.view = v.into();
        self
    }
}

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

/// Message for response to listing Users
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListUsersResponse {
    /// The list of User
    pub users: std::vec::Vec<crate::model::User>,

    /// A token identifying a page of results the user should return.
    pub next_page_token: std::string::String,

    /// Unordered list. 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 ListUsersResponse {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

    /// Sets the value of [next_page_token][crate::model::ListUsersResponse::next_page_token].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::ListUsersResponse;
    /// let x = ListUsersResponse::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::ListUsersResponse::unreachable].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::ListUsersResponse;
    /// let x = ListUsersResponse::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 ListUsersResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.ftp.v1.ListUsersResponse"
    }
}

#[doc(hidden)]
impl google_cloud_gax::paginator::internal::PageableResponse for ListUsersResponse {
    type PageItem = crate::model::User;

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

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

/// Message for getting a User
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GetUserRequest {
    /// Required. Name of the resource
    pub name: std::string::String,

    /// Optional. The view of the User resource to return.
    pub view: crate::model::UserView,

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

impl GetUserRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::GetUserRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::GetUserRequest;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// # let server_id = "server_id";
    /// # let user_id = "user_id";
    /// let x = GetUserRequest::new().set_name(format!("projects/{project_id}/locations/{location_id}/servers/{server_id}/users/{user_id}"));
    /// ```
    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 [view][crate::model::GetUserRequest::view].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::GetUserRequest;
    /// use google_cloud_ftp_v1::model::UserView;
    /// let x0 = GetUserRequest::new().set_view(UserView::Basic);
    /// let x1 = GetUserRequest::new().set_view(UserView::Full);
    /// ```
    pub fn set_view<T: std::convert::Into<crate::model::UserView>>(mut self, v: T) -> Self {
        self.view = v.into();
        self
    }
}

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

/// Message for creating a User
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CreateUserRequest {
    /// Required. Value for parent.
    pub parent: std::string::String,

    /// Required. A unique user ID for the SFTP user. The user ID must start with a
    /// lowercase letter and can include lowercase letters, numbers, or hyphens.
    pub user_id: std::string::String,

    /// Required. The resource being created
    pub user: std::option::Option<crate::model::User>,

    /// Optional. An optional request ID to identify requests. Specify a unique
    /// request ID so that if you must retry your request, the server will know to
    /// ignore the request if it has already been completed. The server will
    /// guarantee that for at least 60 minutes since the first request.
    ///
    /// For example, consider a situation where you make an initial request and the
    /// request times out. If you make the request again with the same request
    /// ID, the server can check if original operation with the same request ID
    /// was received, and if so, will ignore the second request. This prevents
    /// clients from accidentally creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID with the exception that zero UUID is
    /// not supported (00000000-0000-0000-0000-000000000000).
    pub request_id: std::string::String,

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

impl CreateUserRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::CreateUserRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::CreateUserRequest;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// # let server_id = "server_id";
    /// let x = CreateUserRequest::new().set_parent(format!("projects/{project_id}/locations/{location_id}/servers/{server_id}"));
    /// ```
    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 [user_id][crate::model::CreateUserRequest::user_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::CreateUserRequest;
    /// let x = CreateUserRequest::new().set_user_id("example");
    /// ```
    pub fn set_user_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.user_id = v.into();
        self
    }

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

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

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

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

/// Message for updating a User
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct UpdateUserRequest {
    /// Optional. Field mask is used to specify the fields to be overwritten in the
    /// User resource by the update.
    /// The fields specified in the update_mask are relative to the resource, not
    /// the full request. A field will be overwritten if it is in the mask. If the
    /// user does not provide a mask then all fields present in the request will be
    /// overwritten.
    pub update_mask: std::option::Option<wkt::FieldMask>,

    /// Required. The resource being updated
    pub user: std::option::Option<crate::model::User>,

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

impl UpdateUserRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

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

/// Message for deleting a User
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DeleteUserRequest {
    /// Required. Name of the resource
    pub name: std::string::String,

    /// Optional. If set to true, the request will force the deletion of the User.
    pub force: bool,

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

impl DeleteUserRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::DeleteUserRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::DeleteUserRequest;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// # let server_id = "server_id";
    /// # let user_id = "user_id";
    /// let x = DeleteUserRequest::new().set_name(format!("projects/{project_id}/locations/{location_id}/servers/{server_id}/users/{user_id}"));
    /// ```
    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 [force][crate::model::DeleteUserRequest::force].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::DeleteUserRequest;
    /// let x = DeleteUserRequest::new().set_force(true);
    /// ```
    pub fn set_force<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.force = v.into();
        self
    }
}

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

/// Request message for starting a Server.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct StartServerRequest {
    /// Required. Name of the resource
    /// Format: `projects/{project}/locations/{location}/servers/{server}`
    pub name: std::string::String,

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

impl StartServerRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::StartServerRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::StartServerRequest;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// # let server_id = "server_id";
    /// let x = StartServerRequest::new().set_name(format!("projects/{project_id}/locations/{location_id}/servers/{server_id}"));
    /// ```
    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 StartServerRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.ftp.v1.StartServerRequest"
    }
}

/// Request message for stopping a Server.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct StopServerRequest {
    /// Required. Name of the resource.
    /// Format: `projects/{project}/locations/{location}/servers/{server}`
    pub name: std::string::String,

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

impl StopServerRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::StopServerRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::StopServerRequest;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// # let server_id = "server_id";
    /// let x = StopServerRequest::new().set_name(format!("projects/{project_id}/locations/{location_id}/servers/{server_id}"));
    /// ```
    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 StopServerRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.ftp.v1.StopServerRequest"
    }
}

/// Message describing UserCredential object
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct UserCredential {
    /// Required. Name of the user credential.
    pub credential_name: std::string::String,

    /// Required. Type of credential.
    pub credential_type: crate::model::user_credential::Type,

    /// Optional. SSH public key body in OpenSSH format.
    /// Example: "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQ..."
    pub ssh_public_key_body: std::string::String,

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

impl UserCredential {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

    /// Sets the value of [credential_type][crate::model::UserCredential::credential_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::UserCredential;
    /// use google_cloud_ftp_v1::model::user_credential::Type;
    /// let x0 = UserCredential::new().set_credential_type(Type::PublicKey);
    /// ```
    pub fn set_credential_type<T: std::convert::Into<crate::model::user_credential::Type>>(
        mut self,
        v: T,
    ) -> Self {
        self.credential_type = v.into();
        self
    }

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

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

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

    /// Type of credential.
    ///
    /// # 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://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Type {
        /// Type unspecified.
        Unspecified,
        /// Public key credential.
        PublicKey,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Type::value] or
        /// [Type::name].
        UnknownValue(r#type::UnknownValue),
    }

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

    impl Type {
        /// 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::PublicKey => 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("TYPE_UNSPECIFIED"),
                Self::PublicKey => std::option::Option::Some("PUBLIC_KEY"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

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

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

    impl std::convert::From<&str> for Type {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "TYPE_UNSPECIFIED" => Self::Unspecified,
                "PUBLIC_KEY" => Self::PublicKey,
                _ => Self::UnknownValue(r#type::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

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

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

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

    /// Output only. The time 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_message: std::string::String,

    /// Output only. Identifies whether the user has requested cancellation
    /// of the operation. Operations that have been cancelled successfully
    /// have
    /// [google.longrunning.Operation.error][google.longrunning.Operation.error]
    /// value with a [google.rpc.Status.code][google.rpc.Status.code] of `1`,
    /// corresponding to `Code.CANCELLED`.
    ///
    /// [google.longrunning.Operation.error]: google_cloud_longrunning::model::Operation::result
    /// [google.rpc.Status.code]: google_cloud_rpc::model::Status::code
    pub requested_cancellation: 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 {
    /// Creates a new default instance.
    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_ftp_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_ftp_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_ftp_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_ftp_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_ftp_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_ftp_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_message][crate::model::OperationMetadata::status_message].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_v1::model::OperationMetadata;
    /// let x = OperationMetadata::new().set_status_message("example");
    /// ```
    pub fn set_status_message<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.status_message = v.into();
        self
    }

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

    /// Sets the value of [api_version][crate::model::OperationMetadata::api_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_ftp_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.ftp.v1.OperationMetadata"
    }
}

/// View for Server resource.
///
/// # 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://googleapis.github.io/google-cloud-rust/working_with_enums.html
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum ServerView {
    /// Default value. Equivalent to SERVER_VIEW_BASIC.
    Unspecified,
    /// Basic view. Excludes heavy configurations (internal_config,
    /// external_config, google_managed_server_credential).
    Basic,
    /// Full view. Includes all fields.
    Full,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [ServerView::value] or
    /// [ServerView::name].
    UnknownValue(server_view::UnknownValue),
}

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

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

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

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

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

impl std::convert::From<&str> for ServerView {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "SERVER_VIEW_UNSPECIFIED" => Self::Unspecified,
            "SERVER_VIEW_BASIC" => Self::Basic,
            "SERVER_VIEW_FULL" => Self::Full,
            _ => Self::UnknownValue(server_view::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

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

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

/// View for User resource.
///
/// # 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://googleapis.github.io/google-cloud-rust/working_with_enums.html
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum UserView {
    /// Default value. Equivalent to USER_VIEW_BASIC.
    Unspecified,
    /// Basic view. Excludes heavy configurations (user_credentials,
    /// storage_directory_mappings).
    Basic,
    /// Full view. Includes all fields.
    Full,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [UserView::value] or
    /// [UserView::name].
    UnknownValue(user_view::UnknownValue),
}

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

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

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

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

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

impl std::convert::From<&str> for UserView {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "USER_VIEW_UNSPECIFIED" => Self::Unspecified,
            "USER_VIEW_BASIC" => Self::Basic,
            "USER_VIEW_FULL" => Self::Full,
            _ => Self::UnknownValue(user_view::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

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

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