google-cloud-connectors-v1 0.1.0

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

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

/// AuthConfig defines details of a authentication type.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct AuthConfig {
    /// The type of authentication configured.
    pub auth_type: crate::model::AuthType,

    /// List containing additional auth configs.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub additional_variables: std::vec::Vec<crate::model::ConfigVariable>,

    /// Supported auth types.
    #[serde(flatten, skip_serializing_if = "std::option::Option::is_none")]
    pub r#type: std::option::Option<crate::model::auth_config::Type>,
}

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

    /// Sets the value of [auth_type][crate::model::AuthConfig::auth_type].
    pub fn set_auth_type<T: std::convert::Into<crate::model::AuthType>>(mut self, v: T) -> Self {
        self.auth_type = v.into();
        self
    }

    /// Sets the value of [additional_variables][crate::model::AuthConfig::additional_variables].
    pub fn set_additional_variables<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::ConfigVariable>,
    {
        use std::iter::Iterator;
        self.additional_variables = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of `r#type`.
    pub fn set_type<T: std::convert::Into<std::option::Option<crate::model::auth_config::Type>>>(
        mut self,
        v: T,
    ) -> Self {
        self.r#type = v.into();
        self
    }

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

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

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

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

    /// Sets the value of [r#type][crate::model::AuthConfig::r#type]
    /// to hold a `UserPassword`.
    ///
    /// Note that all the setters affecting `r#type` are
    /// mutually exclusive.
    pub fn set_user_password<
        T: std::convert::Into<std::boxed::Box<crate::model::auth_config::UserPassword>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.r#type =
            std::option::Option::Some(crate::model::auth_config::Type::UserPassword(v.into()));
        self
    }

    /// Sets the value of [r#type][crate::model::AuthConfig::r#type]
    /// to hold a `Oauth2JwtBearer`.
    ///
    /// Note that all the setters affecting `r#type` are
    /// mutually exclusive.
    pub fn set_oauth2_jwt_bearer<
        T: std::convert::Into<std::boxed::Box<crate::model::auth_config::Oauth2JwtBearer>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.r#type =
            std::option::Option::Some(crate::model::auth_config::Type::Oauth2JwtBearer(v.into()));
        self
    }

    /// Sets the value of [r#type][crate::model::AuthConfig::r#type]
    /// to hold a `Oauth2ClientCredentials`.
    ///
    /// Note that all the setters affecting `r#type` are
    /// mutually exclusive.
    pub fn set_oauth2_client_credentials<
        T: std::convert::Into<std::boxed::Box<crate::model::auth_config::Oauth2ClientCredentials>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.r#type = std::option::Option::Some(
            crate::model::auth_config::Type::Oauth2ClientCredentials(v.into()),
        );
        self
    }

    /// Sets the value of [r#type][crate::model::AuthConfig::r#type]
    /// to hold a `SshPublicKey`.
    ///
    /// Note that all the setters affecting `r#type` are
    /// mutually exclusive.
    pub fn set_ssh_public_key<
        T: std::convert::Into<std::boxed::Box<crate::model::auth_config::SshPublicKey>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.r#type =
            std::option::Option::Some(crate::model::auth_config::Type::SshPublicKey(v.into()));
        self
    }
}

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

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

    /// Parameters to support Username and Password Authentication.
    #[serde_with::serde_as]
    #[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
    #[serde(default, rename_all = "camelCase")]
    #[non_exhaustive]
    pub struct UserPassword {
        /// Username.
        #[serde(skip_serializing_if = "std::string::String::is_empty")]
        pub username: std::string::String,

        /// Secret version reference containing the password.
        #[serde(skip_serializing_if = "std::option::Option::is_none")]
        pub password: std::option::Option<crate::model::Secret>,
    }

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

        /// Sets the value of [username][crate::model::auth_config::UserPassword::username].
        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 [password][crate::model::auth_config::UserPassword::password].
        pub fn set_password<T: std::convert::Into<std::option::Option<crate::model::Secret>>>(
            mut self,
            v: T,
        ) -> Self {
            self.password = v.into();
            self
        }
    }

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

    /// Parameters to support JSON Web Token (JWT) Profile for Oauth 2.0
    /// Authorization Grant based authentication.
    /// See <https://tools.ietf.org/html/rfc7523> for more details.
    #[serde_with::serde_as]
    #[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
    #[serde(default, rename_all = "camelCase")]
    #[non_exhaustive]
    pub struct Oauth2JwtBearer {
        /// Secret version reference containing a PKCS#8 PEM-encoded private
        /// key associated with the Client Certificate. This private key will be
        /// used to sign JWTs used for the jwt-bearer authorization grant.
        /// Specified in the form as: `projects/*/secrets/*/versions/*`.
        #[serde(skip_serializing_if = "std::option::Option::is_none")]
        pub client_key: std::option::Option<crate::model::Secret>,

        /// JwtClaims providers fields to generate the token.
        #[serde(skip_serializing_if = "std::option::Option::is_none")]
        pub jwt_claims:
            std::option::Option<crate::model::auth_config::oauth_2_jwt_bearer::JwtClaims>,
    }

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

        /// Sets the value of [client_key][crate::model::auth_config::Oauth2JwtBearer::client_key].
        pub fn set_client_key<T: std::convert::Into<std::option::Option<crate::model::Secret>>>(
            mut self,
            v: T,
        ) -> Self {
            self.client_key = v.into();
            self
        }

        /// Sets the value of [jwt_claims][crate::model::auth_config::Oauth2JwtBearer::jwt_claims].
        pub fn set_jwt_claims<
            T: std::convert::Into<
                std::option::Option<crate::model::auth_config::oauth_2_jwt_bearer::JwtClaims>,
            >,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.jwt_claims = v.into();
            self
        }
    }

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

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

        /// JWT claims used for the jwt-bearer authorization grant.
        #[serde_with::serde_as]
        #[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
        #[serde(default, rename_all = "camelCase")]
        #[non_exhaustive]
        pub struct JwtClaims {
            /// Value for the "iss" claim.
            #[serde(skip_serializing_if = "std::string::String::is_empty")]
            pub issuer: std::string::String,

            /// Value for the "sub" claim.
            #[serde(skip_serializing_if = "std::string::String::is_empty")]
            pub subject: std::string::String,

            /// Value for the "aud" claim.
            #[serde(skip_serializing_if = "std::string::String::is_empty")]
            pub audience: std::string::String,
        }

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

            /// Sets the value of [issuer][crate::model::auth_config::oauth_2_jwt_bearer::JwtClaims::issuer].
            pub fn set_issuer<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
                self.issuer = v.into();
                self
            }

            /// Sets the value of [subject][crate::model::auth_config::oauth_2_jwt_bearer::JwtClaims::subject].
            pub fn set_subject<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
                self.subject = v.into();
                self
            }

            /// Sets the value of [audience][crate::model::auth_config::oauth_2_jwt_bearer::JwtClaims::audience].
            pub fn set_audience<T: std::convert::Into<std::string::String>>(
                mut self,
                v: T,
            ) -> Self {
                self.audience = v.into();
                self
            }
        }

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

    /// Parameters to support Oauth 2.0 Client Credentials Grant Authentication.
    /// See <https://tools.ietf.org/html/rfc6749#section-1.3.4> for more details.
    #[serde_with::serde_as]
    #[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
    #[serde(default, rename_all = "camelCase")]
    #[non_exhaustive]
    pub struct Oauth2ClientCredentials {
        /// The client identifier.
        #[serde(skip_serializing_if = "std::string::String::is_empty")]
        pub client_id: std::string::String,

        /// Secret version reference containing the client secret.
        #[serde(skip_serializing_if = "std::option::Option::is_none")]
        pub client_secret: std::option::Option<crate::model::Secret>,
    }

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

        /// Sets the value of [client_id][crate::model::auth_config::Oauth2ClientCredentials::client_id].
        pub fn set_client_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.client_id = v.into();
            self
        }

        /// Sets the value of [client_secret][crate::model::auth_config::Oauth2ClientCredentials::client_secret].
        pub fn set_client_secret<
            T: std::convert::Into<std::option::Option<crate::model::Secret>>,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.client_secret = v.into();
            self
        }
    }

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

    /// Parameters to support Ssh public key Authentication.
    #[serde_with::serde_as]
    #[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
    #[serde(default, rename_all = "camelCase")]
    #[non_exhaustive]
    pub struct SshPublicKey {
        /// The user account used to authenticate.
        #[serde(skip_serializing_if = "std::string::String::is_empty")]
        pub username: std::string::String,

        /// SSH Client Cert. It should contain both public and private key.
        #[serde(skip_serializing_if = "std::option::Option::is_none")]
        pub ssh_client_cert: std::option::Option<crate::model::Secret>,

        /// Format of SSH Client cert.
        #[serde(skip_serializing_if = "std::string::String::is_empty")]
        pub cert_type: std::string::String,

        /// Password (passphrase) for ssh client certificate if it has one.
        #[serde(skip_serializing_if = "std::option::Option::is_none")]
        pub ssh_client_cert_pass: std::option::Option<crate::model::Secret>,
    }

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

        /// Sets the value of [username][crate::model::auth_config::SshPublicKey::username].
        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 [ssh_client_cert][crate::model::auth_config::SshPublicKey::ssh_client_cert].
        pub fn set_ssh_client_cert<
            T: std::convert::Into<std::option::Option<crate::model::Secret>>,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.ssh_client_cert = v.into();
            self
        }

        /// Sets the value of [cert_type][crate::model::auth_config::SshPublicKey::cert_type].
        pub fn set_cert_type<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.cert_type = v.into();
            self
        }

        /// Sets the value of [ssh_client_cert_pass][crate::model::auth_config::SshPublicKey::ssh_client_cert_pass].
        pub fn set_ssh_client_cert_pass<
            T: std::convert::Into<std::option::Option<crate::model::Secret>>,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.ssh_client_cert_pass = v.into();
            self
        }
    }

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

    /// Supported auth types.
    #[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
    #[serde(rename_all = "camelCase")]
    #[non_exhaustive]
    pub enum Type {
        /// UserPassword.
        UserPassword(std::boxed::Box<crate::model::auth_config::UserPassword>),
        /// Oauth2JwtBearer.
        Oauth2JwtBearer(std::boxed::Box<crate::model::auth_config::Oauth2JwtBearer>),
        /// Oauth2ClientCredentials.
        Oauth2ClientCredentials(
            std::boxed::Box<crate::model::auth_config::Oauth2ClientCredentials>,
        ),
        /// SSH Public Key.
        SshPublicKey(std::boxed::Box<crate::model::auth_config::SshPublicKey>),
    }
}

/// AuthConfigTemplate defines required field over an authentication type.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct AuthConfigTemplate {
    /// The type of authentication configured.
    pub auth_type: crate::model::AuthType,

    /// Config variables to describe an `AuthConfig` for a `Connection`.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub config_variable_templates: std::vec::Vec<crate::model::ConfigVariableTemplate>,

    /// Display name for authentication template.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub display_name: std::string::String,

    /// Connector specific description for an authentication template.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub description: std::string::String,
}

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

    /// Sets the value of [auth_type][crate::model::AuthConfigTemplate::auth_type].
    pub fn set_auth_type<T: std::convert::Into<crate::model::AuthType>>(mut self, v: T) -> Self {
        self.auth_type = v.into();
        self
    }

    /// Sets the value of [display_name][crate::model::AuthConfigTemplate::display_name].
    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 [description][crate::model::AuthConfigTemplate::description].
    pub fn set_description<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.description = v.into();
        self
    }

    /// Sets the value of [config_variable_templates][crate::model::AuthConfigTemplate::config_variable_templates].
    pub fn set_config_variable_templates<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::ConfigVariableTemplate>,
    {
        use std::iter::Iterator;
        self.config_variable_templates = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

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

/// Represents the metadata of the long-running operation.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct OperationMetadata {
    /// Output only. The time the operation was created.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The time the operation finished running.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub end_time: std::option::Option<wkt::Timestamp>,

    /// Output only. Server-defined resource path for the target of the operation.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub target: std::string::String,

    /// Output only. Name of the verb executed by the operation.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub verb: std::string::String,

    /// Output only. Human-readable status of the operation, if any.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub status_message: std::string::String,

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

    /// Output only. API version used to start the operation.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub api_version: std::string::String,
}

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

    /// Sets the value of [create_time][crate::model::OperationMetadata::create_time].
    pub fn set_create_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.create_time = v.into();
        self
    }

    /// Sets the value of [end_time][crate::model::OperationMetadata::end_time].
    pub fn set_end_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.end_time = v.into();
        self
    }

    /// Sets the value of [target][crate::model::OperationMetadata::target].
    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].
    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].
    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].
    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].
    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.connectors.v1.OperationMetadata"
    }
}

/// ConfigVariableTemplate provides metadata about a `ConfigVariable` that is
/// used in a Connection.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ConfigVariableTemplate {
    /// Key of the config variable.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub key: std::string::String,

    /// Type of the parameter: string, int, bool etc.
    /// consider custom type for the benefit for the validation.
    pub value_type: crate::model::config_variable_template::ValueType,

    /// Display name of the parameter.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub display_name: std::string::String,

    /// Description.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub description: std::string::String,

    /// Regular expression in RE2 syntax used for validating the `value` of a
    /// `ConfigVariable`.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub validation_regex: std::string::String,

    /// Flag represents that this `ConfigVariable` must be provided for a
    /// connection.
    pub required: bool,

    /// Role grant configuration for the config variable.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub role_grant: std::option::Option<crate::model::RoleGrant>,

    /// Enum options. To be populated if `ValueType` is `ENUM`
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub enum_options: std::vec::Vec<crate::model::EnumOption>,

    /// Authorization code link options. To be populated if `ValueType` is
    /// `AUTHORIZATION_CODE`
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub authorization_code_link: std::option::Option<crate::model::AuthorizationCodeLink>,

    /// State of the config variable.
    pub state: crate::model::config_variable_template::State,

    /// Indicates if current template is part of advanced settings
    pub is_advanced: bool,
}

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

    /// Sets the value of [key][crate::model::ConfigVariableTemplate::key].
    pub fn set_key<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.key = v.into();
        self
    }

    /// Sets the value of [value_type][crate::model::ConfigVariableTemplate::value_type].
    pub fn set_value_type<
        T: std::convert::Into<crate::model::config_variable_template::ValueType>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.value_type = v.into();
        self
    }

    /// Sets the value of [display_name][crate::model::ConfigVariableTemplate::display_name].
    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 [description][crate::model::ConfigVariableTemplate::description].
    pub fn set_description<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.description = v.into();
        self
    }

    /// Sets the value of [validation_regex][crate::model::ConfigVariableTemplate::validation_regex].
    pub fn set_validation_regex<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.validation_regex = v.into();
        self
    }

    /// Sets the value of [required][crate::model::ConfigVariableTemplate::required].
    pub fn set_required<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.required = v.into();
        self
    }

    /// Sets the value of [role_grant][crate::model::ConfigVariableTemplate::role_grant].
    pub fn set_role_grant<T: std::convert::Into<std::option::Option<crate::model::RoleGrant>>>(
        mut self,
        v: T,
    ) -> Self {
        self.role_grant = v.into();
        self
    }

    /// Sets the value of [authorization_code_link][crate::model::ConfigVariableTemplate::authorization_code_link].
    pub fn set_authorization_code_link<
        T: std::convert::Into<std::option::Option<crate::model::AuthorizationCodeLink>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.authorization_code_link = v.into();
        self
    }

    /// Sets the value of [state][crate::model::ConfigVariableTemplate::state].
    pub fn set_state<T: std::convert::Into<crate::model::config_variable_template::State>>(
        mut self,
        v: T,
    ) -> Self {
        self.state = v.into();
        self
    }

    /// Sets the value of [is_advanced][crate::model::ConfigVariableTemplate::is_advanced].
    pub fn set_is_advanced<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.is_advanced = v.into();
        self
    }

    /// Sets the value of [enum_options][crate::model::ConfigVariableTemplate::enum_options].
    pub fn set_enum_options<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::EnumOption>,
    {
        use std::iter::Iterator;
        self.enum_options = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

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

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

    /// ValueType indicates the data type of the value.
    #[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
    pub struct ValueType(std::borrow::Cow<'static, str>);

    impl ValueType {
        /// Creates a new ValueType instance.
        pub const fn new(v: &'static str) -> Self {
            Self(std::borrow::Cow::Borrowed(v))
        }

        /// Gets the enum value.
        pub fn value(&self) -> &str {
            &self.0
        }
    }

    /// Useful constants to work with [ValueType](ValueType)
    pub mod value_type {
        use super::ValueType;

        /// Value type is not specified.
        pub const VALUE_TYPE_UNSPECIFIED: ValueType = ValueType::new("VALUE_TYPE_UNSPECIFIED");

        /// Value type is string.
        pub const STRING: ValueType = ValueType::new("STRING");

        /// Value type is integer.
        pub const INT: ValueType = ValueType::new("INT");

        /// Value type is boolean.
        pub const BOOL: ValueType = ValueType::new("BOOL");

        /// Value type is secret.
        pub const SECRET: ValueType = ValueType::new("SECRET");

        /// Value type is enum.
        pub const ENUM: ValueType = ValueType::new("ENUM");

        /// Value type is authorization code.
        pub const AUTHORIZATION_CODE: ValueType = ValueType::new("AUTHORIZATION_CODE");
    }

    impl std::convert::From<std::string::String> for ValueType {
        fn from(value: std::string::String) -> Self {
            Self(std::borrow::Cow::Owned(value))
        }
    }

    /// Indicates the state of the config variable.
    #[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
    pub struct State(std::borrow::Cow<'static, str>);

    impl State {
        /// Creates a new State instance.
        pub const fn new(v: &'static str) -> Self {
            Self(std::borrow::Cow::Borrowed(v))
        }

        /// Gets the enum value.
        pub fn value(&self) -> &str {
            &self.0
        }
    }

    /// Useful constants to work with [State](State)
    pub mod state {
        use super::State;

        /// Status is unspecified.
        pub const STATE_UNSPECIFIED: State = State::new("STATE_UNSPECIFIED");

        /// Config variable is active
        pub const ACTIVE: State = State::new("ACTIVE");

        /// Config variable is deprecated.
        pub const DEPRECATED: State = State::new("DEPRECATED");
    }

    impl std::convert::From<std::string::String> for State {
        fn from(value: std::string::String) -> Self {
            Self(std::borrow::Cow::Owned(value))
        }
    }
}

/// Secret provides a reference to entries in Secret Manager.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct Secret {
    /// The resource name of the secret version in the format,
    /// format as: `projects/*/secrets/*/versions/*`.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub secret_version: std::string::String,
}

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

    /// Sets the value of [secret_version][crate::model::Secret::secret_version].
    pub fn set_secret_version<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.secret_version = v.into();
        self
    }
}

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

/// EnumOption definition
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct EnumOption {
    /// Id of the option.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub id: std::string::String,

    /// Display name of the option.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub display_name: std::string::String,
}

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

    /// Sets the value of [id][crate::model::EnumOption::id].
    pub fn set_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.id = v.into();
        self
    }

    /// Sets the value of [display_name][crate::model::EnumOption::display_name].
    pub fn set_display_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.display_name = v.into();
        self
    }
}

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

/// ConfigVariable represents a configuration variable present in a Connection.
/// or AuthConfig.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ConfigVariable {
    /// Key of the config variable.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub key: std::string::String,

    /// Value type of the config variable.
    #[serde(flatten, skip_serializing_if = "std::option::Option::is_none")]
    pub value: std::option::Option<crate::model::config_variable::Value>,
}

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

    /// Sets the value of [key][crate::model::ConfigVariable::key].
    pub fn set_key<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.key = v.into();
        self
    }

    /// Sets the value of `value`.
    pub fn set_value<
        T: std::convert::Into<std::option::Option<crate::model::config_variable::Value>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.value = v.into();
        self
    }

    /// The value of [value][crate::model::ConfigVariable::value]
    /// if it holds a `IntValue`, `None` if the field is not set or
    /// holds a different branch.
    pub fn get_int_value(&self) -> std::option::Option<&i64> {
        #[allow(unreachable_patterns)]
        self.value.as_ref().and_then(|v| match v {
            crate::model::config_variable::Value::IntValue(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// The value of [value][crate::model::ConfigVariable::value]
    /// if it holds a `BoolValue`, `None` if the field is not set or
    /// holds a different branch.
    pub fn get_bool_value(&self) -> std::option::Option<&bool> {
        #[allow(unreachable_patterns)]
        self.value.as_ref().and_then(|v| match v {
            crate::model::config_variable::Value::BoolValue(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

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

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

    /// Sets the value of [value][crate::model::ConfigVariable::value]
    /// to hold a `IntValue`.
    ///
    /// Note that all the setters affecting `value` are
    /// mutually exclusive.
    pub fn set_int_value<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
        self.value =
            std::option::Option::Some(crate::model::config_variable::Value::IntValue(v.into()));
        self
    }

    /// Sets the value of [value][crate::model::ConfigVariable::value]
    /// to hold a `BoolValue`.
    ///
    /// Note that all the setters affecting `value` are
    /// mutually exclusive.
    pub fn set_bool_value<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.value =
            std::option::Option::Some(crate::model::config_variable::Value::BoolValue(v.into()));
        self
    }

    /// Sets the value of [value][crate::model::ConfigVariable::value]
    /// to hold a `StringValue`.
    ///
    /// Note that all the setters affecting `value` are
    /// mutually exclusive.
    pub fn set_string_value<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.value =
            std::option::Option::Some(crate::model::config_variable::Value::StringValue(v.into()));
        self
    }

    /// Sets the value of [value][crate::model::ConfigVariable::value]
    /// to hold a `SecretValue`.
    ///
    /// Note that all the setters affecting `value` are
    /// mutually exclusive.
    pub fn set_secret_value<T: std::convert::Into<std::boxed::Box<crate::model::Secret>>>(
        mut self,
        v: T,
    ) -> Self {
        self.value =
            std::option::Option::Some(crate::model::config_variable::Value::SecretValue(v.into()));
        self
    }
}

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

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

    /// Value type of the config variable.
    #[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
    #[serde(rename_all = "camelCase")]
    #[non_exhaustive]
    pub enum Value {
        /// Value is an integer
        IntValue(i64),
        /// Value is a bool.
        BoolValue(bool),
        /// Value is a string.
        StringValue(std::string::String),
        /// Value is a secret.
        SecretValue(std::boxed::Box<crate::model::Secret>),
    }
}

/// This configuration defines all the Cloud IAM roles that needs to be granted
/// to a particular GCP resource for the selected prinicpal like service
/// account. These configurations will let UI display to customers what
/// IAM roles need to be granted by them. Or these configurations can be used
/// by the UI to render a 'grant' button to do the same on behalf of the user.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct RoleGrant {
    /// Prinicipal/Identity for whom the role need to assigned.
    pub principal: crate::model::role_grant::Principal,

    /// List of roles that need to be granted.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub roles: std::vec::Vec<std::string::String>,

    /// Resource on which the roles needs to be granted for the principal.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub resource: std::option::Option<crate::model::role_grant::Resource>,

    /// Template that UI can use to provide helper text to customers.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub helper_text_template: std::string::String,
}

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

    /// Sets the value of [principal][crate::model::RoleGrant::principal].
    pub fn set_principal<T: std::convert::Into<crate::model::role_grant::Principal>>(
        mut self,
        v: T,
    ) -> Self {
        self.principal = v.into();
        self
    }

    /// Sets the value of [resource][crate::model::RoleGrant::resource].
    pub fn set_resource<
        T: std::convert::Into<std::option::Option<crate::model::role_grant::Resource>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.resource = v.into();
        self
    }

    /// Sets the value of [helper_text_template][crate::model::RoleGrant::helper_text_template].
    pub fn set_helper_text_template<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.helper_text_template = v.into();
        self
    }

    /// Sets the value of [roles][crate::model::RoleGrant::roles].
    pub fn set_roles<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.roles = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

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

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

    /// Resource definition
    #[serde_with::serde_as]
    #[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
    #[serde(default, rename_all = "camelCase")]
    #[non_exhaustive]
    pub struct Resource {
        /// Different types of resource supported.
        #[serde(rename = "type")]
        pub r#type: crate::model::role_grant::resource::Type,

        /// Template to uniquely represent a GCP resource in a format IAM expects
        /// This is a template that can have references to other values provided in
        /// the config variable template.
        #[serde(skip_serializing_if = "std::string::String::is_empty")]
        pub path_template: std::string::String,
    }

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

        /// Sets the value of [r#type][crate::model::role_grant::Resource::type].
        pub fn set_type<T: std::convert::Into<crate::model::role_grant::resource::Type>>(
            mut self,
            v: T,
        ) -> Self {
            self.r#type = v.into();
            self
        }

        /// Sets the value of [path_template][crate::model::role_grant::Resource::path_template].
        pub fn set_path_template<T: std::convert::Into<std::string::String>>(
            mut self,
            v: T,
        ) -> Self {
            self.path_template = v.into();
            self
        }
    }

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

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

        /// Resource Type definition.
        #[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
        pub struct Type(std::borrow::Cow<'static, str>);

        impl Type {
            /// Creates a new Type instance.
            pub const fn new(v: &'static str) -> Self {
                Self(std::borrow::Cow::Borrowed(v))
            }

            /// Gets the enum value.
            pub fn value(&self) -> &str {
                &self.0
            }
        }

        /// Useful constants to work with [Type](Type)
        pub mod r#type {
            use super::Type;

            /// Value type is not specified.
            pub const TYPE_UNSPECIFIED: Type = Type::new("TYPE_UNSPECIFIED");

            /// GCP Project Resource.
            pub const GCP_PROJECT: Type = Type::new("GCP_PROJECT");

            /// Any GCP Resource which is identified uniquely by IAM.
            pub const GCP_RESOURCE: Type = Type::new("GCP_RESOURCE");

            /// GCP Secret Resource.
            pub const GCP_SECRETMANAGER_SECRET: Type = Type::new("GCP_SECRETMANAGER_SECRET");

            /// GCP Secret Version Resource.
            pub const GCP_SECRETMANAGER_SECRET_VERSION: Type =
                Type::new("GCP_SECRETMANAGER_SECRET_VERSION");
        }

        impl std::convert::From<std::string::String> for Type {
            fn from(value: std::string::String) -> Self {
                Self(std::borrow::Cow::Owned(value))
            }
        }
    }

    /// Supported Principal values.
    #[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
    pub struct Principal(std::borrow::Cow<'static, str>);

    impl Principal {
        /// Creates a new Principal instance.
        pub const fn new(v: &'static str) -> Self {
            Self(std::borrow::Cow::Borrowed(v))
        }

        /// Gets the enum value.
        pub fn value(&self) -> &str {
            &self.0
        }
    }

    /// Useful constants to work with [Principal](Principal)
    pub mod principal {
        use super::Principal;

        /// Value type is not specified.
        pub const PRINCIPAL_UNSPECIFIED: Principal = Principal::new("PRINCIPAL_UNSPECIFIED");

        /// Service Account used for Connector workload identity
        /// This is either the default service account if unspecified or Service
        /// Account provided by Customers through BYOSA.
        pub const CONNECTOR_SA: Principal = Principal::new("CONNECTOR_SA");
    }

    impl std::convert::From<std::string::String> for Principal {
        fn from(value: std::string::String) -> Self {
            Self(std::borrow::Cow::Owned(value))
        }
    }
}

/// This configuration captures the details required to render an authorization
/// link for the OAuth Authorization Code Flow.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct AuthorizationCodeLink {
    /// The base URI the user must click to trigger the authorization code login
    /// flow.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub uri: std::string::String,

    /// The scopes for which the user will authorize GCP Connectors on the
    /// connector data source.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub scopes: std::vec::Vec<std::string::String>,

    /// The client ID assigned to the GCP Connectors OAuth app for the connector
    /// data source.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub client_id: std::string::String,

    /// Whether to enable PKCE for the auth code flow.
    pub enable_pkce: bool,
}

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

    /// Sets the value of [uri][crate::model::AuthorizationCodeLink::uri].
    pub fn set_uri<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.uri = v.into();
        self
    }

    /// Sets the value of [client_id][crate::model::AuthorizationCodeLink::client_id].
    pub fn set_client_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.client_id = v.into();
        self
    }

    /// Sets the value of [enable_pkce][crate::model::AuthorizationCodeLink::enable_pkce].
    pub fn set_enable_pkce<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enable_pkce = v.into();
        self
    }

    /// Sets the value of [scopes][crate::model::AuthorizationCodeLink::scopes].
    pub fn set_scopes<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.scopes = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

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

/// Connection represents an instance of connector.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct Connection {
    /// Output only. Resource name of the Connection.
    /// Format: projects/{project}/locations/{location}/connections/{connection}
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,

    /// Output only. Created time.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. Updated time.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub update_time: std::option::Option<wkt::Timestamp>,

    /// Optional. Resource labels to represent user-provided metadata.
    /// Refer to cloud documentation on labels for more details.
    /// <https://cloud.google.com/compute/docs/labeling-resources>
    #[serde(skip_serializing_if = "std::collections::HashMap::is_empty")]
    pub labels: std::collections::HashMap<std::string::String, std::string::String>,

    /// Optional. Description of the resource.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub description: std::string::String,

    /// Required. Connector version on which the connection is created.
    /// The format is:
    /// projects/*/locations/*/providers/*/connectors/*/versions/*
    /// Only global location is supported for ConnectorVersion resource.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub connector_version: std::string::String,

    /// Output only. Current status of the connection.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub status: std::option::Option<crate::model::ConnectionStatus>,

    /// Optional. Configuration for configuring the connection with an external
    /// system.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub config_variables: std::vec::Vec<crate::model::ConfigVariable>,

    /// Optional. Configuration for establishing the connection's authentication
    /// with an external system.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub auth_config: std::option::Option<crate::model::AuthConfig>,

    /// Optional. Configuration that indicates whether or not the Connection can be
    /// edited.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub lock_config: std::option::Option<crate::model::LockConfig>,

    /// Optional. Configuration of the Connector's destination. Only accepted for
    /// Connectors that accepts user defined destination(s).
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub destination_configs: std::vec::Vec<crate::model::DestinationConfig>,

    /// Output only. GCR location where the runtime image is stored.
    /// formatted like: gcr.io/{bucketName}/{imageName}
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub image_location: std::string::String,

    /// Optional. Service account needed for runtime plane to access GCP resources.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub service_account: std::string::String,

    /// Output only. The name of the Service Directory service name. Used for
    /// Private Harpoon to resolve the ILB address.
    /// e.g.
    /// "projects/cloud-connectors-e2e-testing/locations/us-central1/namespaces/istio-system/services/istio-ingressgateway-connectors"
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub service_directory: std::string::String,

    /// Output only. GCR location where the envoy image is stored.
    /// formatted like: gcr.io/{bucketName}/{imageName}
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub envoy_image_location: std::string::String,

    /// Optional. Suspended indicates if a user has suspended a connection or not.
    pub suspended: bool,

    /// Optional. Node configuration for the connection.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub node_config: std::option::Option<crate::model::NodeConfig>,

    /// Optional. Ssl config of a connection
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub ssl_config: std::option::Option<crate::model::SslConfig>,
}

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

    /// Sets the value of [name][crate::model::Connection::name].
    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::Connection::create_time].
    pub fn set_create_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.create_time = v.into();
        self
    }

    /// Sets the value of [update_time][crate::model::Connection::update_time].
    pub fn set_update_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.update_time = v.into();
        self
    }

    /// Sets the value of [description][crate::model::Connection::description].
    pub fn set_description<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.description = v.into();
        self
    }

    /// Sets the value of [connector_version][crate::model::Connection::connector_version].
    pub fn set_connector_version<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.connector_version = v.into();
        self
    }

    /// Sets the value of [status][crate::model::Connection::status].
    pub fn set_status<
        T: std::convert::Into<std::option::Option<crate::model::ConnectionStatus>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.status = v.into();
        self
    }

    /// Sets the value of [auth_config][crate::model::Connection::auth_config].
    pub fn set_auth_config<T: std::convert::Into<std::option::Option<crate::model::AuthConfig>>>(
        mut self,
        v: T,
    ) -> Self {
        self.auth_config = v.into();
        self
    }

    /// Sets the value of [lock_config][crate::model::Connection::lock_config].
    pub fn set_lock_config<T: std::convert::Into<std::option::Option<crate::model::LockConfig>>>(
        mut self,
        v: T,
    ) -> Self {
        self.lock_config = v.into();
        self
    }

    /// Sets the value of [image_location][crate::model::Connection::image_location].
    pub fn set_image_location<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.image_location = v.into();
        self
    }

    /// Sets the value of [service_account][crate::model::Connection::service_account].
    pub fn set_service_account<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.service_account = v.into();
        self
    }

    /// Sets the value of [service_directory][crate::model::Connection::service_directory].
    pub fn set_service_directory<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.service_directory = v.into();
        self
    }

    /// Sets the value of [envoy_image_location][crate::model::Connection::envoy_image_location].
    pub fn set_envoy_image_location<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.envoy_image_location = v.into();
        self
    }

    /// Sets the value of [suspended][crate::model::Connection::suspended].
    pub fn set_suspended<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.suspended = v.into();
        self
    }

    /// Sets the value of [node_config][crate::model::Connection::node_config].
    pub fn set_node_config<T: std::convert::Into<std::option::Option<crate::model::NodeConfig>>>(
        mut self,
        v: T,
    ) -> Self {
        self.node_config = v.into();
        self
    }

    /// Sets the value of [ssl_config][crate::model::Connection::ssl_config].
    pub fn set_ssl_config<T: std::convert::Into<std::option::Option<crate::model::SslConfig>>>(
        mut self,
        v: T,
    ) -> Self {
        self.ssl_config = v.into();
        self
    }

    /// Sets the value of [config_variables][crate::model::Connection::config_variables].
    pub fn set_config_variables<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::ConfigVariable>,
    {
        use std::iter::Iterator;
        self.config_variables = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [destination_configs][crate::model::Connection::destination_configs].
    pub fn set_destination_configs<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::DestinationConfig>,
    {
        use std::iter::Iterator;
        self.destination_configs = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [labels][crate::model::Connection::labels].
    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
    }
}

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

/// Node configuration for the connection.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct NodeConfig {
    /// Minimum number of nodes in the runtime nodes.
    pub min_node_count: i32,

    /// Maximum number of nodes in the runtime nodes.
    pub max_node_count: i32,
}

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

    /// Sets the value of [min_node_count][crate::model::NodeConfig::min_node_count].
    pub fn set_min_node_count<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.min_node_count = v.into();
        self
    }

    /// Sets the value of [max_node_count][crate::model::NodeConfig::max_node_count].
    pub fn set_max_node_count<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.max_node_count = v.into();
        self
    }
}

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

/// ConnectionSchemaMetadata is the singleton resource of each connection.
/// It includes the entity and action names of runtime resources exposed
/// by a connection backend.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ConnectionSchemaMetadata {
    /// Output only. List of entity names.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub entities: std::vec::Vec<std::string::String>,

    /// Output only. List of actions.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub actions: std::vec::Vec<std::string::String>,

    /// Output only. Resource name.
    /// Format:
    /// projects/{project}/locations/{location}/connections/{connection}/connectionSchemaMetadata
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,

    /// Output only. Timestamp when the connection runtime schema was updated.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub update_time: std::option::Option<wkt::Timestamp>,

    /// Output only. Timestamp when the connection runtime schema refresh was
    /// triggered.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub refresh_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The current state of runtime schema.
    pub state: crate::model::connection_schema_metadata::State,
}

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

    /// Sets the value of [name][crate::model::ConnectionSchemaMetadata::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [update_time][crate::model::ConnectionSchemaMetadata::update_time].
    pub fn set_update_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.update_time = v.into();
        self
    }

    /// Sets the value of [refresh_time][crate::model::ConnectionSchemaMetadata::refresh_time].
    pub fn set_refresh_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.refresh_time = v.into();
        self
    }

    /// Sets the value of [state][crate::model::ConnectionSchemaMetadata::state].
    pub fn set_state<T: std::convert::Into<crate::model::connection_schema_metadata::State>>(
        mut self,
        v: T,
    ) -> Self {
        self.state = v.into();
        self
    }

    /// Sets the value of [entities][crate::model::ConnectionSchemaMetadata::entities].
    pub fn set_entities<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.entities = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [actions][crate::model::ConnectionSchemaMetadata::actions].
    pub fn set_actions<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.actions = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

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

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

    /// State of connection runtime schema.
    #[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
    pub struct State(std::borrow::Cow<'static, str>);

    impl State {
        /// Creates a new State instance.
        pub const fn new(v: &'static str) -> Self {
            Self(std::borrow::Cow::Borrowed(v))
        }

        /// Gets the enum value.
        pub fn value(&self) -> &str {
            &self.0
        }
    }

    /// Useful constants to work with [State](State)
    pub mod state {
        use super::State;

        /// Default state.
        pub const STATE_UNSPECIFIED: State = State::new("STATE_UNSPECIFIED");

        /// Schema refresh is in progress.
        pub const REFRESHING: State = State::new("REFRESHING");

        /// Schema has been updated.
        pub const UPDATED: State = State::new("UPDATED");
    }

    impl std::convert::From<std::string::String> for State {
        fn from(value: std::string::String) -> Self {
            Self(std::borrow::Cow::Owned(value))
        }
    }
}

/// Schema of a runtime entity.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct RuntimeEntitySchema {
    /// Output only. Name of the entity.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub entity: std::string::String,

    /// Output only. List of fields in the entity.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub fields: std::vec::Vec<crate::model::runtime_entity_schema::Field>,
}

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

    /// Sets the value of [entity][crate::model::RuntimeEntitySchema::entity].
    pub fn set_entity<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.entity = v.into();
        self
    }

    /// Sets the value of [fields][crate::model::RuntimeEntitySchema::fields].
    pub fn set_fields<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::runtime_entity_schema::Field>,
    {
        use std::iter::Iterator;
        self.fields = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

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

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

    /// Metadata of an entity field.
    #[serde_with::serde_as]
    #[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
    #[serde(default, rename_all = "camelCase")]
    #[non_exhaustive]
    pub struct Field {
        /// Name of the Field.
        #[serde(skip_serializing_if = "std::string::String::is_empty")]
        pub field: std::string::String,

        /// A brief description of the Field.
        #[serde(skip_serializing_if = "std::string::String::is_empty")]
        pub description: std::string::String,

        /// The data type of the Field.
        pub data_type: crate::model::DataType,

        /// The following boolean field specifies if the current Field acts
        /// as a primary key or id if the parent is of type entity.
        pub key: bool,

        /// Specifies if the Field is readonly.
        pub readonly: bool,

        /// Specifies whether a null value is allowed.
        pub nullable: bool,

        /// The following field specifies the default value of the Field provided
        /// by the external system if a value is not provided.
        #[serde(skip_serializing_if = "std::option::Option::is_none")]
        pub default_value: std::option::Option<wkt::Value>,

        /// The following map contains fields that are not explicitly mentioned
        /// above,this give connectors the flexibility to add new metadata
        /// fields.
        #[serde(skip_serializing_if = "std::option::Option::is_none")]
        pub additional_details: std::option::Option<wkt::Struct>,
    }

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

        /// Sets the value of [field][crate::model::runtime_entity_schema::Field::field].
        pub fn set_field<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.field = v.into();
            self
        }

        /// Sets the value of [description][crate::model::runtime_entity_schema::Field::description].
        pub fn set_description<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.description = v.into();
            self
        }

        /// Sets the value of [data_type][crate::model::runtime_entity_schema::Field::data_type].
        pub fn set_data_type<T: std::convert::Into<crate::model::DataType>>(
            mut self,
            v: T,
        ) -> Self {
            self.data_type = v.into();
            self
        }

        /// Sets the value of [key][crate::model::runtime_entity_schema::Field::key].
        pub fn set_key<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
            self.key = v.into();
            self
        }

        /// Sets the value of [readonly][crate::model::runtime_entity_schema::Field::readonly].
        pub fn set_readonly<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
            self.readonly = v.into();
            self
        }

        /// Sets the value of [nullable][crate::model::runtime_entity_schema::Field::nullable].
        pub fn set_nullable<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
            self.nullable = v.into();
            self
        }

        /// Sets the value of [default_value][crate::model::runtime_entity_schema::Field::default_value].
        pub fn set_default_value<T: std::convert::Into<std::option::Option<wkt::Value>>>(
            mut self,
            v: T,
        ) -> Self {
            self.default_value = v.into();
            self
        }

        /// Sets the value of [additional_details][crate::model::runtime_entity_schema::Field::additional_details].
        pub fn set_additional_details<T: std::convert::Into<std::option::Option<wkt::Struct>>>(
            mut self,
            v: T,
        ) -> Self {
            self.additional_details = v.into();
            self
        }
    }

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

/// Schema of a runtime action.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct RuntimeActionSchema {
    /// Output only. Name of the action.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub action: std::string::String,

    /// Output only. List of input parameter metadata for the action.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub input_parameters: std::vec::Vec<crate::model::runtime_action_schema::InputParameter>,

    /// Output only. List of result field metadata.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub result_metadata: std::vec::Vec<crate::model::runtime_action_schema::ResultMetadata>,
}

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

    /// Sets the value of [action][crate::model::RuntimeActionSchema::action].
    pub fn set_action<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.action = v.into();
        self
    }

    /// Sets the value of [input_parameters][crate::model::RuntimeActionSchema::input_parameters].
    pub fn set_input_parameters<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::runtime_action_schema::InputParameter>,
    {
        use std::iter::Iterator;
        self.input_parameters = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [result_metadata][crate::model::RuntimeActionSchema::result_metadata].
    pub fn set_result_metadata<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::runtime_action_schema::ResultMetadata>,
    {
        use std::iter::Iterator;
        self.result_metadata = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

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

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

    /// Metadata of an input parameter.
    #[serde_with::serde_as]
    #[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
    #[serde(default, rename_all = "camelCase")]
    #[non_exhaustive]
    pub struct InputParameter {
        /// Name of the Parameter.
        #[serde(skip_serializing_if = "std::string::String::is_empty")]
        pub parameter: std::string::String,

        /// A brief description of the Parameter.
        #[serde(skip_serializing_if = "std::string::String::is_empty")]
        pub description: std::string::String,

        /// The data type of the Parameter.
        pub data_type: crate::model::DataType,

        /// Specifies whether a null value is allowed.
        pub nullable: bool,

        /// The following field specifies the default value of the Parameter
        /// provided by the external system if a value is not provided.
        #[serde(skip_serializing_if = "std::option::Option::is_none")]
        pub default_value: std::option::Option<wkt::Value>,
    }

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

        /// Sets the value of [parameter][crate::model::runtime_action_schema::InputParameter::parameter].
        pub fn set_parameter<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.parameter = v.into();
            self
        }

        /// Sets the value of [description][crate::model::runtime_action_schema::InputParameter::description].
        pub fn set_description<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.description = v.into();
            self
        }

        /// Sets the value of [data_type][crate::model::runtime_action_schema::InputParameter::data_type].
        pub fn set_data_type<T: std::convert::Into<crate::model::DataType>>(
            mut self,
            v: T,
        ) -> Self {
            self.data_type = v.into();
            self
        }

        /// Sets the value of [nullable][crate::model::runtime_action_schema::InputParameter::nullable].
        pub fn set_nullable<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
            self.nullable = v.into();
            self
        }

        /// Sets the value of [default_value][crate::model::runtime_action_schema::InputParameter::default_value].
        pub fn set_default_value<T: std::convert::Into<std::option::Option<wkt::Value>>>(
            mut self,
            v: T,
        ) -> Self {
            self.default_value = v.into();
            self
        }
    }

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

    /// Metadata of result field.
    #[serde_with::serde_as]
    #[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
    #[serde(default, rename_all = "camelCase")]
    #[non_exhaustive]
    pub struct ResultMetadata {
        /// Name of the result field.
        #[serde(skip_serializing_if = "std::string::String::is_empty")]
        pub field: std::string::String,

        /// A brief description of the field.
        #[serde(skip_serializing_if = "std::string::String::is_empty")]
        pub description: std::string::String,

        /// The data type of the field.
        pub data_type: crate::model::DataType,
    }

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

        /// Sets the value of [field][crate::model::runtime_action_schema::ResultMetadata::field].
        pub fn set_field<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.field = v.into();
            self
        }

        /// Sets the value of [description][crate::model::runtime_action_schema::ResultMetadata::description].
        pub fn set_description<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.description = v.into();
            self
        }

        /// Sets the value of [data_type][crate::model::runtime_action_schema::ResultMetadata::data_type].
        pub fn set_data_type<T: std::convert::Into<crate::model::DataType>>(
            mut self,
            v: T,
        ) -> Self {
            self.data_type = v.into();
            self
        }
    }

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

/// Determines whether or no a connection is locked. If locked, a reason must be
/// specified.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct LockConfig {
    /// Indicates whether or not the connection is locked.
    pub locked: bool,

    /// Describes why a connection is locked.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub reason: std::string::String,
}

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

    /// Sets the value of [locked][crate::model::LockConfig::locked].
    pub fn set_locked<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.locked = v.into();
        self
    }

    /// Sets the value of [reason][crate::model::LockConfig::reason].
    pub fn set_reason<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.reason = v.into();
        self
    }
}

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

/// Request message for ConnectorsService.ListConnections
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ListConnectionsRequest {
    /// Required. Parent resource of the Connection, of the form:
    /// `projects/*/locations/*`
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub parent: std::string::String,

    /// Page size.
    pub page_size: i32,

    /// Page token.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub page_token: std::string::String,

    /// Filter.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub filter: std::string::String,

    /// Order by parameters.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub order_by: std::string::String,

    /// Specifies which fields of the Connection are returned in the response.
    /// Defaults to `BASIC` view.
    pub view: crate::model::ConnectionView,
}

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

    /// Sets the value of [parent][crate::model::ListConnectionsRequest::parent].
    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::ListConnectionsRequest::page_size].
    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::ListConnectionsRequest::page_token].
    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::ListConnectionsRequest::filter].
    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::ListConnectionsRequest::order_by].
    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::ListConnectionsRequest::view].
    pub fn set_view<T: std::convert::Into<crate::model::ConnectionView>>(mut self, v: T) -> Self {
        self.view = v.into();
        self
    }
}

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

/// Response message for ConnectorsService.ListConnections
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ListConnectionsResponse {
    /// Connections.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub connections: std::vec::Vec<crate::model::Connection>,

    /// Next page token.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub next_page_token: std::string::String,

    /// Locations that could not be reached.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub unreachable: std::vec::Vec<std::string::String>,
}

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

    /// Sets the value of [next_page_token][crate::model::ListConnectionsResponse::next_page_token].
    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 [connections][crate::model::ListConnectionsResponse::connections].
    pub fn set_connections<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::Connection>,
    {
        use std::iter::Iterator;
        self.connections = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [unreachable][crate::model::ListConnectionsResponse::unreachable].
    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 ListConnectionsResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.connectors.v1.ListConnectionsResponse"
    }
}

#[cfg(feature = "unstable-stream")]
impl gax::paginator::PageableResponse for ListConnectionsResponse {
    type PageItem = crate::model::Connection;

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

    fn next_page_token(&self) -> std::string::String {
        gax::paginator::extract_token(&self.next_page_token)
    }
}

/// Request message for ConnectorsService.GetConnection
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct GetConnectionRequest {
    /// Required. Resource name of the form:
    /// `projects/*/locations/*/connections/*`
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,

    /// Specifies which fields of the Connection are returned in the response.
    /// Defaults to `BASIC` view.
    pub view: crate::model::ConnectionView,
}

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

    /// Sets the value of [name][crate::model::GetConnectionRequest::name].
    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::GetConnectionRequest::view].
    pub fn set_view<T: std::convert::Into<crate::model::ConnectionView>>(mut self, v: T) -> Self {
        self.view = v.into();
        self
    }
}

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

/// Request message for ConnectorsService.CreateConnection
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct CreateConnectionRequest {
    /// Required. Parent resource of the Connection, of the form:
    /// `projects/*/locations/*`
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub parent: std::string::String,

    /// Required. Identifier to assign to the Connection. Must be unique within
    /// scope of the parent resource.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub connection_id: std::string::String,

    /// Required. Connection resource.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub connection: std::option::Option<crate::model::Connection>,
}

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

    /// Sets the value of [parent][crate::model::CreateConnectionRequest::parent].
    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 [connection_id][crate::model::CreateConnectionRequest::connection_id].
    pub fn set_connection_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.connection_id = v.into();
        self
    }

    /// Sets the value of [connection][crate::model::CreateConnectionRequest::connection].
    pub fn set_connection<T: std::convert::Into<std::option::Option<crate::model::Connection>>>(
        mut self,
        v: T,
    ) -> Self {
        self.connection = v.into();
        self
    }
}

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

/// Request message for ConnectorsService.UpdateConnection
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct UpdateConnectionRequest {
    /// Required. Connection resource.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub connection: std::option::Option<crate::model::Connection>,

    /// Required. You can modify only the fields listed below.
    ///
    /// To lock/unlock a connection:
    ///
    /// * `lock_config`
    ///
    /// To suspend/resume a connection:
    ///
    /// * `suspended`
    ///
    /// To update the connection details:
    ///
    /// * `description`
    /// * `labels`
    /// * `connector_version`
    /// * `config_variables`
    /// * `auth_config`
    /// * `destination_configs`
    /// * `node_config`
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub update_mask: std::option::Option<wkt::FieldMask>,
}

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

    /// Sets the value of [connection][crate::model::UpdateConnectionRequest::connection].
    pub fn set_connection<T: std::convert::Into<std::option::Option<crate::model::Connection>>>(
        mut self,
        v: T,
    ) -> Self {
        self.connection = v.into();
        self
    }

    /// Sets the value of [update_mask][crate::model::UpdateConnectionRequest::update_mask].
    pub fn set_update_mask<T: std::convert::Into<std::option::Option<wkt::FieldMask>>>(
        mut self,
        v: T,
    ) -> Self {
        self.update_mask = v.into();
        self
    }
}

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

/// Request message for ConnectorsService.DeleteConnection.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct DeleteConnectionRequest {
    /// Required. Resource name of the form:
    /// `projects/*/locations/*/connections/*`
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,
}

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

    /// Sets the value of [name][crate::model::DeleteConnectionRequest::name].
    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 DeleteConnectionRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.connectors.v1.DeleteConnectionRequest"
    }
}

/// Request message for ConnectorsService.GetConnectionSchemaMetadata.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct GetConnectionSchemaMetadataRequest {
    /// Required. Connection name
    /// Format:
    /// projects/{project}/locations/{location}/connections/{connection}/connectionSchemaMetadata
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,
}

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

    /// Sets the value of [name][crate::model::GetConnectionSchemaMetadataRequest::name].
    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 GetConnectionSchemaMetadataRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.connectors.v1.GetConnectionSchemaMetadataRequest"
    }
}

/// Request message for ConnectorsService.RefreshConnectionSchemaMetadata.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct RefreshConnectionSchemaMetadataRequest {
    /// Required. Resource name.
    /// Format:
    /// projects/{project}/locations/{location}/connections/{connection}/connectionSchemaMetadata
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,
}

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

    /// Sets the value of [name][crate::model::RefreshConnectionSchemaMetadataRequest::name].
    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 RefreshConnectionSchemaMetadataRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.connectors.v1.RefreshConnectionSchemaMetadataRequest"
    }
}

/// Request message for ConnectorsService.ListRuntimeEntitySchemas.
/// For filter, only entity field is supported with literal equality operator.
/// Accepted filter example: entity="Order"
/// Wildcards are not supported in the filter currently.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ListRuntimeEntitySchemasRequest {
    /// Required. Parent resource of RuntimeEntitySchema
    /// Format:
    /// projects/{project}/locations/{location}/connections/{connection}
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub parent: std::string::String,

    /// Page size.
    pub page_size: i32,

    /// Page token.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub page_token: std::string::String,

    /// Required. Filter
    /// Format:
    /// entity="{entityId}"
    /// Only entity field is supported with literal equality operator.
    /// Accepted filter example: entity="Order"
    /// Wildcards are not supported in the filter currently.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub filter: std::string::String,
}

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

    /// Sets the value of [parent][crate::model::ListRuntimeEntitySchemasRequest::parent].
    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::ListRuntimeEntitySchemasRequest::page_size].
    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::ListRuntimeEntitySchemasRequest::page_token].
    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::ListRuntimeEntitySchemasRequest::filter].
    pub fn set_filter<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.filter = v.into();
        self
    }
}

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

/// Response message for ConnectorsService.ListRuntimeEntitySchemas.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ListRuntimeEntitySchemasResponse {
    /// Runtime entity schemas.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub runtime_entity_schemas: std::vec::Vec<crate::model::RuntimeEntitySchema>,

    /// Next page token.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub next_page_token: std::string::String,
}

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

    /// Sets the value of [next_page_token][crate::model::ListRuntimeEntitySchemasResponse::next_page_token].
    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 [runtime_entity_schemas][crate::model::ListRuntimeEntitySchemasResponse::runtime_entity_schemas].
    pub fn set_runtime_entity_schemas<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::RuntimeEntitySchema>,
    {
        use std::iter::Iterator;
        self.runtime_entity_schemas = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

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

#[cfg(feature = "unstable-stream")]
impl gax::paginator::PageableResponse for ListRuntimeEntitySchemasResponse {
    type PageItem = crate::model::RuntimeEntitySchema;

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

    fn next_page_token(&self) -> std::string::String {
        gax::paginator::extract_token(&self.next_page_token)
    }
}

/// Request message for ConnectorsService.ListRuntimeActionSchemas.
/// For filter, only action field is supported with literal equality operator.
/// Accepted filter example: action="approveOrder"
/// Wildcards are not supported in the filter currently.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ListRuntimeActionSchemasRequest {
    /// Required. Parent resource of RuntimeActionSchema
    /// Format:
    /// projects/{project}/locations/{location}/connections/{connection}
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub parent: std::string::String,

    /// Page size.
    pub page_size: i32,

    /// Page token.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub page_token: std::string::String,

    /// Required. Filter
    /// Format:
    /// action="{actionId}"
    /// Only action field is supported with literal equality operator.
    /// Accepted filter example: action="CancelOrder"
    /// Wildcards are not supported in the filter currently.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub filter: std::string::String,
}

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

    /// Sets the value of [parent][crate::model::ListRuntimeActionSchemasRequest::parent].
    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::ListRuntimeActionSchemasRequest::page_size].
    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::ListRuntimeActionSchemasRequest::page_token].
    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::ListRuntimeActionSchemasRequest::filter].
    pub fn set_filter<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.filter = v.into();
        self
    }
}

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

/// Response message for ConnectorsService.ListRuntimeActionSchemas.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ListRuntimeActionSchemasResponse {
    /// Runtime action schemas.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub runtime_action_schemas: std::vec::Vec<crate::model::RuntimeActionSchema>,

    /// Next page token.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub next_page_token: std::string::String,
}

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

    /// Sets the value of [next_page_token][crate::model::ListRuntimeActionSchemasResponse::next_page_token].
    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 [runtime_action_schemas][crate::model::ListRuntimeActionSchemasResponse::runtime_action_schemas].
    pub fn set_runtime_action_schemas<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::RuntimeActionSchema>,
    {
        use std::iter::Iterator;
        self.runtime_action_schemas = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

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

#[cfg(feature = "unstable-stream")]
impl gax::paginator::PageableResponse for ListRuntimeActionSchemasResponse {
    type PageItem = crate::model::RuntimeActionSchema;

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

    fn next_page_token(&self) -> std::string::String {
        gax::paginator::extract_token(&self.next_page_token)
    }
}

/// ConnectionStatus indicates the state of the connection.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ConnectionStatus {
    /// State.
    pub state: crate::model::connection_status::State,

    /// Description.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub description: std::string::String,

    /// Status provides detailed information for the state.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub status: std::string::String,
}

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

    /// Sets the value of [state][crate::model::ConnectionStatus::state].
    pub fn set_state<T: std::convert::Into<crate::model::connection_status::State>>(
        mut self,
        v: T,
    ) -> Self {
        self.state = v.into();
        self
    }

    /// Sets the value of [description][crate::model::ConnectionStatus::description].
    pub fn set_description<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.description = v.into();
        self
    }

    /// Sets the value of [status][crate::model::ConnectionStatus::status].
    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 ConnectionStatus {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.connectors.v1.ConnectionStatus"
    }
}

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

    /// All the possible Connection State.
    #[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
    pub struct State(std::borrow::Cow<'static, str>);

    impl State {
        /// Creates a new State instance.
        pub const fn new(v: &'static str) -> Self {
            Self(std::borrow::Cow::Borrowed(v))
        }

        /// Gets the enum value.
        pub fn value(&self) -> &str {
            &self.0
        }
    }

    /// Useful constants to work with [State](State)
    pub mod state {
        use super::State;

        /// Connection does not have a state yet.
        pub const STATE_UNSPECIFIED: State = State::new("STATE_UNSPECIFIED");

        /// Connection is being created.
        pub const CREATING: State = State::new("CREATING");

        /// Connection is running and ready for requests.
        pub const ACTIVE: State = State::new("ACTIVE");

        /// Connection is stopped.
        pub const INACTIVE: State = State::new("INACTIVE");

        /// Connection is being deleted.
        pub const DELETING: State = State::new("DELETING");

        /// Connection is being updated.
        pub const UPDATING: State = State::new("UPDATING");

        /// Connection is not running due to an error.
        pub const ERROR: State = State::new("ERROR");

        /// Connection is not running due to an auth error for the Oauth2 Auth Code
        /// based connector.
        pub const AUTHORIZATION_REQUIRED: State = State::new("AUTHORIZATION_REQUIRED");
    }

    impl std::convert::From<std::string::String> for State {
        fn from(value: std::string::String) -> Self {
            Self(std::borrow::Cow::Owned(value))
        }
    }
}

/// Connectors indicates a specific connector type, e.x. Salesforce, SAP etc.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct Connector {
    /// Output only. Resource name of the Connector.
    /// Format:
    /// projects/{project}/locations/{location}/providers/{provider}/connectors/{connector}
    /// Only global location is supported for Connector resource.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,

    /// Output only. Created time.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. Updated time.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub update_time: std::option::Option<wkt::Timestamp>,

    /// Output only. Resource labels to represent user-provided metadata.
    /// Refer to cloud documentation on labels for more details.
    /// <https://cloud.google.com/compute/docs/labeling-resources>
    #[serde(skip_serializing_if = "std::collections::HashMap::is_empty")]
    pub labels: std::collections::HashMap<std::string::String, std::string::String>,

    /// Output only. Link to documentation page.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub documentation_uri: std::string::String,

    /// Output only. Link to external page.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub external_uri: std::string::String,

    /// Output only. Description of the resource.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub description: std::string::String,

    /// Output only. Cloud storage location of icons etc consumed by UI.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub web_assets_location: std::string::String,

    /// Output only. Display name.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub display_name: std::string::String,

    /// Output only. Flag to mark the version indicating the launch stage.
    pub launch_stage: crate::model::LaunchStage,
}

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

    /// Sets the value of [name][crate::model::Connector::name].
    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::Connector::create_time].
    pub fn set_create_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.create_time = v.into();
        self
    }

    /// Sets the value of [update_time][crate::model::Connector::update_time].
    pub fn set_update_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.update_time = v.into();
        self
    }

    /// Sets the value of [documentation_uri][crate::model::Connector::documentation_uri].
    pub fn set_documentation_uri<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.documentation_uri = v.into();
        self
    }

    /// Sets the value of [external_uri][crate::model::Connector::external_uri].
    pub fn set_external_uri<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.external_uri = v.into();
        self
    }

    /// Sets the value of [description][crate::model::Connector::description].
    pub fn set_description<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.description = v.into();
        self
    }

    /// Sets the value of [web_assets_location][crate::model::Connector::web_assets_location].
    pub fn set_web_assets_location<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.web_assets_location = v.into();
        self
    }

    /// Sets the value of [display_name][crate::model::Connector::display_name].
    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 [launch_stage][crate::model::Connector::launch_stage].
    pub fn set_launch_stage<T: std::convert::Into<crate::model::LaunchStage>>(
        mut self,
        v: T,
    ) -> Self {
        self.launch_stage = v.into();
        self
    }

    /// Sets the value of [labels][crate::model::Connector::labels].
    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
    }
}

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

/// Request message for Connectors.GetConnector.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct GetConnectorRequest {
    /// Required. Resource name of the form:
    /// `projects/*/locations/*/providers/*/connectors/*`
    /// Only global location is supported for Connector resource.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,
}

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

    /// Sets the value of [name][crate::model::GetConnectorRequest::name].
    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 GetConnectorRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.connectors.v1.GetConnectorRequest"
    }
}

/// Request message for Connectors.ListConnectors.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ListConnectorsRequest {
    /// Required. Parent resource of the connectors, of the form:
    /// `projects/*/locations/*/providers/*`
    /// Only global location is supported for Connector resource.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub parent: std::string::String,

    /// Page size.
    pub page_size: i32,

    /// Page token.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub page_token: std::string::String,
}

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

    /// Sets the value of [parent][crate::model::ListConnectorsRequest::parent].
    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::ListConnectorsRequest::page_size].
    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::ListConnectorsRequest::page_token].
    pub fn set_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.page_token = v.into();
        self
    }
}

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

/// Response message for Connectors.ListConnectors.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ListConnectorsResponse {
    /// A list of connectors.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub connectors: std::vec::Vec<crate::model::Connector>,

    /// Next page token.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub next_page_token: std::string::String,

    /// Locations that could not be reached.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub unreachable: std::vec::Vec<std::string::String>,
}

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

    /// Sets the value of [next_page_token][crate::model::ListConnectorsResponse::next_page_token].
    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 [connectors][crate::model::ListConnectorsResponse::connectors].
    pub fn set_connectors<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::Connector>,
    {
        use std::iter::Iterator;
        self.connectors = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [unreachable][crate::model::ListConnectorsResponse::unreachable].
    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 ListConnectorsResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.connectors.v1.ListConnectorsResponse"
    }
}

#[cfg(feature = "unstable-stream")]
impl gax::paginator::PageableResponse for ListConnectorsResponse {
    type PageItem = crate::model::Connector;

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

    fn next_page_token(&self) -> std::string::String {
        gax::paginator::extract_token(&self.next_page_token)
    }
}

/// ConnectorVersion indicates a specific version of a connector.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ConnectorVersion {
    /// Output only. Resource name of the Version.
    /// Format:
    /// projects/{project}/locations/{location}/providers/{provider}/connectors/{connector}/versions/{version}
    /// Only global location is supported for Connector resource.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,

    /// Output only. Created time.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. Updated time.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub update_time: std::option::Option<wkt::Timestamp>,

    /// Output only. Resource labels to represent user-provided metadata.
    /// Refer to cloud documentation on labels for more details.
    /// <https://cloud.google.com/compute/docs/labeling-resources>
    #[serde(skip_serializing_if = "std::collections::HashMap::is_empty")]
    pub labels: std::collections::HashMap<std::string::String, std::string::String>,

    /// Output only. Flag to mark the version indicating the launch stage.
    pub launch_stage: crate::model::LaunchStage,

    /// Output only. ReleaseVersion of the connector, for example: "1.0.1-alpha".
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub release_version: std::string::String,

    /// Output only. List of auth configs supported by the Connector Version.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub auth_config_templates: std::vec::Vec<crate::model::AuthConfigTemplate>,

    /// Output only. List of config variables needed to create a connection.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub config_variable_templates: std::vec::Vec<crate::model::ConfigVariableTemplate>,

    /// Output only. Information about the runtime features supported by the
    /// Connector.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub supported_runtime_features: std::option::Option<crate::model::SupportedRuntimeFeatures>,

    /// Output only. Display name.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub display_name: std::string::String,

    /// Output only. Configuration for Egress Control.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub egress_control_config: std::option::Option<crate::model::EgressControlConfig>,

    /// Output only. Role grant configurations for this connector version.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub role_grants: std::vec::Vec<crate::model::RoleGrant>,

    /// Output only. Role grant configuration for this config variable. It will be
    /// DEPRECATED soon.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub role_grant: std::option::Option<crate::model::RoleGrant>,

    /// Output only. Ssl configuration supported by the Connector.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub ssl_config_template: std::option::Option<crate::model::SslConfigTemplate>,
}

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

    /// Sets the value of [name][crate::model::ConnectorVersion::name].
    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::ConnectorVersion::create_time].
    pub fn set_create_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.create_time = v.into();
        self
    }

    /// Sets the value of [update_time][crate::model::ConnectorVersion::update_time].
    pub fn set_update_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.update_time = v.into();
        self
    }

    /// Sets the value of [launch_stage][crate::model::ConnectorVersion::launch_stage].
    pub fn set_launch_stage<T: std::convert::Into<crate::model::LaunchStage>>(
        mut self,
        v: T,
    ) -> Self {
        self.launch_stage = v.into();
        self
    }

    /// Sets the value of [release_version][crate::model::ConnectorVersion::release_version].
    pub fn set_release_version<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.release_version = v.into();
        self
    }

    /// Sets the value of [supported_runtime_features][crate::model::ConnectorVersion::supported_runtime_features].
    pub fn set_supported_runtime_features<
        T: std::convert::Into<std::option::Option<crate::model::SupportedRuntimeFeatures>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.supported_runtime_features = v.into();
        self
    }

    /// Sets the value of [display_name][crate::model::ConnectorVersion::display_name].
    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 [egress_control_config][crate::model::ConnectorVersion::egress_control_config].
    pub fn set_egress_control_config<
        T: std::convert::Into<std::option::Option<crate::model::EgressControlConfig>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.egress_control_config = v.into();
        self
    }

    /// Sets the value of [role_grant][crate::model::ConnectorVersion::role_grant].
    pub fn set_role_grant<T: std::convert::Into<std::option::Option<crate::model::RoleGrant>>>(
        mut self,
        v: T,
    ) -> Self {
        self.role_grant = v.into();
        self
    }

    /// Sets the value of [ssl_config_template][crate::model::ConnectorVersion::ssl_config_template].
    pub fn set_ssl_config_template<
        T: std::convert::Into<std::option::Option<crate::model::SslConfigTemplate>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.ssl_config_template = v.into();
        self
    }

    /// Sets the value of [auth_config_templates][crate::model::ConnectorVersion::auth_config_templates].
    pub fn set_auth_config_templates<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::AuthConfigTemplate>,
    {
        use std::iter::Iterator;
        self.auth_config_templates = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [config_variable_templates][crate::model::ConnectorVersion::config_variable_templates].
    pub fn set_config_variable_templates<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::ConfigVariableTemplate>,
    {
        use std::iter::Iterator;
        self.config_variable_templates = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [role_grants][crate::model::ConnectorVersion::role_grants].
    pub fn set_role_grants<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::RoleGrant>,
    {
        use std::iter::Iterator;
        self.role_grants = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [labels][crate::model::ConnectorVersion::labels].
    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
    }
}

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

/// Request message for Connectors.GetConnectorVersion.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct GetConnectorVersionRequest {
    /// Required. Resource name of the form:
    /// `projects/*/locations/*/providers/*/connectors/*/versions/*`
    /// Only global location is supported for ConnectorVersion resource.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,

    /// Specifies which fields of the ConnectorVersion are returned in the
    /// response. Defaults to `CUSTOMER` view.
    pub view: crate::model::ConnectorVersionView,
}

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

    /// Sets the value of [name][crate::model::GetConnectorVersionRequest::name].
    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::GetConnectorVersionRequest::view].
    pub fn set_view<T: std::convert::Into<crate::model::ConnectorVersionView>>(
        mut self,
        v: T,
    ) -> Self {
        self.view = v.into();
        self
    }
}

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

/// Request message for Connectors.ListConnectorVersions.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ListConnectorVersionsRequest {
    /// Required. Parent resource of the connectors, of the form:
    /// `projects/*/locations/*/providers/*/connectors/*`
    /// Only global location is supported for ConnectorVersion resource.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub parent: std::string::String,

    /// Page size.
    pub page_size: i32,

    /// Page token.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub page_token: std::string::String,

    /// Specifies which fields of the ConnectorVersion are returned in the
    /// response. Defaults to `BASIC` view.
    pub view: crate::model::ConnectorVersionView,
}

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

    /// Sets the value of [parent][crate::model::ListConnectorVersionsRequest::parent].
    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::ListConnectorVersionsRequest::page_size].
    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::ListConnectorVersionsRequest::page_token].
    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 [view][crate::model::ListConnectorVersionsRequest::view].
    pub fn set_view<T: std::convert::Into<crate::model::ConnectorVersionView>>(
        mut self,
        v: T,
    ) -> Self {
        self.view = v.into();
        self
    }
}

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

/// Response message for Connectors.ListConnectorVersions.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ListConnectorVersionsResponse {
    /// A list of connector versions.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub connector_versions: std::vec::Vec<crate::model::ConnectorVersion>,

    /// Next page token.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub next_page_token: std::string::String,

    /// Locations that could not be reached.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub unreachable: std::vec::Vec<std::string::String>,
}

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

    /// Sets the value of [next_page_token][crate::model::ListConnectorVersionsResponse::next_page_token].
    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 [connector_versions][crate::model::ListConnectorVersionsResponse::connector_versions].
    pub fn set_connector_versions<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::ConnectorVersion>,
    {
        use std::iter::Iterator;
        self.connector_versions = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [unreachable][crate::model::ListConnectorVersionsResponse::unreachable].
    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 ListConnectorVersionsResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.connectors.v1.ListConnectorVersionsResponse"
    }
}

#[cfg(feature = "unstable-stream")]
impl gax::paginator::PageableResponse for ListConnectorVersionsResponse {
    type PageItem = crate::model::ConnectorVersion;

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

    fn next_page_token(&self) -> std::string::String {
        gax::paginator::extract_token(&self.next_page_token)
    }
}

/// Supported runtime features of a connector version. This is passed to the
/// management layer to add a new connector version by the connector developer.
/// Details about how this proto is passed to the management layer is covered in
/// this doc - go/runtime-manifest.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct SupportedRuntimeFeatures {
    /// Specifies if the connector supports entity apis like 'createEntity'.
    pub entity_apis: bool,

    /// Specifies if the connector supports action apis like 'executeAction'.
    pub action_apis: bool,

    /// Specifies if the connector supports 'ExecuteSqlQuery' operation.
    pub sql_query: bool,
}

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

    /// Sets the value of [entity_apis][crate::model::SupportedRuntimeFeatures::entity_apis].
    pub fn set_entity_apis<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.entity_apis = v.into();
        self
    }

    /// Sets the value of [action_apis][crate::model::SupportedRuntimeFeatures::action_apis].
    pub fn set_action_apis<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.action_apis = v.into();
        self
    }

    /// Sets the value of [sql_query][crate::model::SupportedRuntimeFeatures::sql_query].
    pub fn set_sql_query<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.sql_query = v.into();
        self
    }
}

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

/// Egress control config for connector runtime. These configurations define the
/// rules to identify which outbound domains/hosts needs to be whitelisted. It
/// may be a static information for a particular connector version or it is
/// derived from the configurations provided by the customer in Connection
/// resource.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct EgressControlConfig {
    #[serde(flatten, skip_serializing_if = "std::option::Option::is_none")]
    pub oneof_backends: std::option::Option<crate::model::egress_control_config::OneofBackends>,
}

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

    /// Sets the value of `oneof_backends`.
    pub fn set_oneof_backends<
        T: std::convert::Into<std::option::Option<crate::model::egress_control_config::OneofBackends>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.oneof_backends = v.into();
        self
    }

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

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

    /// Sets the value of [oneof_backends][crate::model::EgressControlConfig::oneof_backends]
    /// to hold a `Backends`.
    ///
    /// Note that all the setters affecting `oneof_backends` are
    /// mutually exclusive.
    pub fn set_backends<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.oneof_backends = std::option::Option::Some(
            crate::model::egress_control_config::OneofBackends::Backends(v.into()),
        );
        self
    }

    /// Sets the value of [oneof_backends][crate::model::EgressControlConfig::oneof_backends]
    /// to hold a `ExtractionRules`.
    ///
    /// Note that all the setters affecting `oneof_backends` are
    /// mutually exclusive.
    pub fn set_extraction_rules<
        T: std::convert::Into<std::boxed::Box<crate::model::ExtractionRules>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.oneof_backends = std::option::Option::Some(
            crate::model::egress_control_config::OneofBackends::ExtractionRules(v.into()),
        );
        self
    }
}

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

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

    #[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
    #[serde(rename_all = "camelCase")]
    #[non_exhaustive]
    pub enum OneofBackends {
        /// Static Comma separated backends which are common for all Connection
        /// resources. Supported formats for each backend are host:port or just
        /// host (host can be ip address or domain name).
        Backends(std::string::String),
        /// Extractions Rules to extract the backends from customer provided
        /// configuration.
        ExtractionRules(std::boxed::Box<crate::model::ExtractionRules>),
    }
}

/// Extraction Rules to identity the backends from customer provided
/// configuration in Connection resource.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ExtractionRules {
    /// Collection of Extraction Rule.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub extraction_rule: std::vec::Vec<crate::model::ExtractionRule>,
}

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

    /// Sets the value of [extraction_rule][crate::model::ExtractionRules::extraction_rule].
    pub fn set_extraction_rule<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::ExtractionRule>,
    {
        use std::iter::Iterator;
        self.extraction_rule = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

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

/// Extraction Rule.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ExtractionRule {
    /// Source on which the rule is applied.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub source: std::option::Option<crate::model::extraction_rule::Source>,

    /// Regex used to extract backend details from source. If empty, whole source
    /// value will be used.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub extraction_regex: std::string::String,
}

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

    /// Sets the value of [source][crate::model::ExtractionRule::source].
    pub fn set_source<
        T: std::convert::Into<std::option::Option<crate::model::extraction_rule::Source>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.source = v.into();
        self
    }

    /// Sets the value of [extraction_regex][crate::model::ExtractionRule::extraction_regex].
    pub fn set_extraction_regex<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.extraction_regex = v.into();
        self
    }
}

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

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

    /// Source to extract the backend from.
    #[serde_with::serde_as]
    #[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
    #[serde(default, rename_all = "camelCase")]
    #[non_exhaustive]
    pub struct Source {
        /// Type of the source.
        pub source_type: crate::model::extraction_rule::SourceType,

        /// Field identifier. For example config vaiable name.
        #[serde(skip_serializing_if = "std::string::String::is_empty")]
        pub field_id: std::string::String,
    }

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

        /// Sets the value of [source_type][crate::model::extraction_rule::Source::source_type].
        pub fn set_source_type<T: std::convert::Into<crate::model::extraction_rule::SourceType>>(
            mut self,
            v: T,
        ) -> Self {
            self.source_type = v.into();
            self
        }

        /// Sets the value of [field_id][crate::model::extraction_rule::Source::field_id].
        pub fn set_field_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.field_id = v.into();
            self
        }
    }

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

    /// Supported Source types for extraction.
    #[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
    pub struct SourceType(std::borrow::Cow<'static, str>);

    impl SourceType {
        /// Creates a new SourceType instance.
        pub const fn new(v: &'static str) -> Self {
            Self(std::borrow::Cow::Borrowed(v))
        }

        /// Gets the enum value.
        pub fn value(&self) -> &str {
            &self.0
        }
    }

    /// Useful constants to work with [SourceType](SourceType)
    pub mod source_type {
        use super::SourceType;

        /// Default SOURCE.
        pub const SOURCE_TYPE_UNSPECIFIED: SourceType = SourceType::new("SOURCE_TYPE_UNSPECIFIED");

        /// Config Variable source type.
        pub const CONFIG_VARIABLE: SourceType = SourceType::new("CONFIG_VARIABLE");
    }

    impl std::convert::From<std::string::String> for SourceType {
        fn from(value: std::string::String) -> Self {
            Self(std::borrow::Cow::Owned(value))
        }
    }
}

/// Define the Connectors target endpoint.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct DestinationConfig {
    /// The key is the destination identifier that is supported by the Connector.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub key: std::string::String,

    /// The destinations for the key.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub destinations: std::vec::Vec<crate::model::Destination>,
}

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

    /// Sets the value of [key][crate::model::DestinationConfig::key].
    pub fn set_key<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.key = v.into();
        self
    }

    /// Sets the value of [destinations][crate::model::DestinationConfig::destinations].
    pub fn set_destinations<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::Destination>,
    {
        use std::iter::Iterator;
        self.destinations = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

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

#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct Destination {
    /// The port is the target port number that is accepted by the destination.
    pub port: i32,

    #[serde(flatten, skip_serializing_if = "std::option::Option::is_none")]
    pub destination: std::option::Option<crate::model::destination::Destination>,
}

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

    /// Sets the value of [port][crate::model::Destination::port].
    pub fn set_port<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.port = v.into();
        self
    }

    /// Sets the value of `destination`.
    pub fn set_destination<
        T: std::convert::Into<std::option::Option<crate::model::destination::Destination>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.destination = v.into();
        self
    }

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

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

    /// Sets the value of [destination][crate::model::Destination::destination]
    /// to hold a `ServiceAttachment`.
    ///
    /// Note that all the setters affecting `destination` are
    /// mutually exclusive.
    pub fn set_service_attachment<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.destination = std::option::Option::Some(
            crate::model::destination::Destination::ServiceAttachment(v.into()),
        );
        self
    }

    /// Sets the value of [destination][crate::model::Destination::destination]
    /// to hold a `Host`.
    ///
    /// Note that all the setters affecting `destination` are
    /// mutually exclusive.
    pub fn set_host<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.destination =
            std::option::Option::Some(crate::model::destination::Destination::Host(v.into()));
        self
    }
}

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

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

    #[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
    #[serde(rename_all = "camelCase")]
    #[non_exhaustive]
    pub enum Destination {
        /// PSC service attachments.
        /// Format: projects/*/regions/*/serviceAttachments/*
        ServiceAttachment(std::string::String),
        /// For publicly routable host.
        Host(std::string::String),
    }
}

/// Provider indicates the owner who provides the connectors.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct Provider {
    /// Output only. Resource name of the Provider.
    /// Format: projects/{project}/locations/{location}/providers/{provider}
    /// Only global location is supported for Provider resource.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,

    /// Output only. Created time.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. Updated time.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub update_time: std::option::Option<wkt::Timestamp>,

    /// Output only. Resource labels to represent user-provided metadata.
    /// Refer to cloud documentation on labels for more details.
    /// <https://cloud.google.com/compute/docs/labeling-resources>
    #[serde(skip_serializing_if = "std::collections::HashMap::is_empty")]
    pub labels: std::collections::HashMap<std::string::String, std::string::String>,

    /// Output only. Link to documentation page.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub documentation_uri: std::string::String,

    /// Output only. Link to external page.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub external_uri: std::string::String,

    /// Output only. Description of the resource.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub description: std::string::String,

    /// Output only. Cloud storage location of icons etc consumed by UI.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub web_assets_location: std::string::String,

    /// Output only. Display name.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub display_name: std::string::String,

    /// Output only. Flag to mark the version indicating the launch stage.
    pub launch_stage: crate::model::LaunchStage,
}

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

    /// Sets the value of [name][crate::model::Provider::name].
    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::Provider::create_time].
    pub fn set_create_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.create_time = v.into();
        self
    }

    /// Sets the value of [update_time][crate::model::Provider::update_time].
    pub fn set_update_time<T: std::convert::Into<std::option::Option<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.update_time = v.into();
        self
    }

    /// Sets the value of [documentation_uri][crate::model::Provider::documentation_uri].
    pub fn set_documentation_uri<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.documentation_uri = v.into();
        self
    }

    /// Sets the value of [external_uri][crate::model::Provider::external_uri].
    pub fn set_external_uri<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.external_uri = v.into();
        self
    }

    /// Sets the value of [description][crate::model::Provider::description].
    pub fn set_description<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.description = v.into();
        self
    }

    /// Sets the value of [web_assets_location][crate::model::Provider::web_assets_location].
    pub fn set_web_assets_location<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.web_assets_location = v.into();
        self
    }

    /// Sets the value of [display_name][crate::model::Provider::display_name].
    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 [launch_stage][crate::model::Provider::launch_stage].
    pub fn set_launch_stage<T: std::convert::Into<crate::model::LaunchStage>>(
        mut self,
        v: T,
    ) -> Self {
        self.launch_stage = v.into();
        self
    }

    /// Sets the value of [labels][crate::model::Provider::labels].
    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
    }
}

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

/// Request message for Connectors.GetProvider.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct GetProviderRequest {
    /// Required. Resource name of the form:
    /// `projects/*/locations/*/providers/*`
    /// Only global location is supported for Provider resource.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,
}

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

    /// Sets the value of [name][crate::model::GetProviderRequest::name].
    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 GetProviderRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.connectors.v1.GetProviderRequest"
    }
}

/// Request message for Connectors.ListProviders.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ListProvidersRequest {
    /// Required. Parent resource of the API, of the form:
    /// `projects/*/locations/*`
    /// Only global location is supported for Provider resource.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub parent: std::string::String,

    /// Page size.
    pub page_size: i32,

    /// Page token.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub page_token: std::string::String,
}

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

    /// Sets the value of [parent][crate::model::ListProvidersRequest::parent].
    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::ListProvidersRequest::page_size].
    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::ListProvidersRequest::page_token].
    pub fn set_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.page_token = v.into();
        self
    }
}

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

/// Response message for Connectors.ListProviders.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct ListProvidersResponse {
    /// A list of providers.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub providers: std::vec::Vec<crate::model::Provider>,

    /// Next page token.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub next_page_token: std::string::String,

    /// Locations that could not be reached.
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub unreachable: std::vec::Vec<std::string::String>,
}

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

    /// Sets the value of [next_page_token][crate::model::ListProvidersResponse::next_page_token].
    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 [providers][crate::model::ListProvidersResponse::providers].
    pub fn set_providers<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::Provider>,
    {
        use std::iter::Iterator;
        self.providers = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [unreachable][crate::model::ListProvidersResponse::unreachable].
    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 ListProvidersResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.connectors.v1.ListProvidersResponse"
    }
}

#[cfg(feature = "unstable-stream")]
impl gax::paginator::PageableResponse for ListProvidersResponse {
    type PageItem = crate::model::Provider;

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

    fn next_page_token(&self) -> std::string::String {
        gax::paginator::extract_token(&self.next_page_token)
    }
}

/// Request message for Connectors.GetRuntimeConfig.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct GetRuntimeConfigRequest {
    /// Required. Resource name of the form:
    /// `projects/*/locations/*/runtimeConfig`
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,
}

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

    /// Sets the value of [name][crate::model::GetRuntimeConfigRequest::name].
    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 GetRuntimeConfigRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.connectors.v1.GetRuntimeConfigRequest"
    }
}

/// RuntimeConfig is the singleton resource of each location.
/// It includes generic resource configs consumed by control plane and runtime
/// plane like: pub/sub topic/subscription resource name, Cloud Storage location
/// storing schema etc.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct RuntimeConfig {
    /// Output only. location_id of the runtime location. E.g. "us-west1".
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub location_id: std::string::String,

    /// Output only. Pub/Sub topic for connd to send message.
    /// E.g. projects/{project-id}/topics/{topic-id}
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub connd_topic: std::string::String,

    /// Output only. Pub/Sub subscription for connd to receive message.
    /// E.g. projects/{project-id}/subscriptions/{topic-id}
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub connd_subscription: std::string::String,

    /// Output only. Pub/Sub topic for control plne to send message.
    /// communication.
    /// E.g. projects/{project-id}/topics/{topic-id}
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub control_plane_topic: std::string::String,

    /// Output only. Pub/Sub subscription for control plane to receive message.
    /// E.g. projects/{project-id}/subscriptions/{topic-id}
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub control_plane_subscription: std::string::String,

    /// Output only. The endpoint of the connectors runtime ingress.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub runtime_endpoint: std::string::String,

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

    /// Output only. The Cloud Storage bucket that stores connector's schema
    /// reports.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub schema_gcs_bucket: std::string::String,

    /// Output only. The name of the Service Directory service name.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub service_directory: std::string::String,

    /// Output only. Name of the runtimeConfig resource.
    /// Format: projects/{project}/locations/{location}/runtimeConfig
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,
}

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

    /// Sets the value of [location_id][crate::model::RuntimeConfig::location_id].
    pub fn set_location_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.location_id = v.into();
        self
    }

    /// Sets the value of [connd_topic][crate::model::RuntimeConfig::connd_topic].
    pub fn set_connd_topic<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.connd_topic = v.into();
        self
    }

    /// Sets the value of [connd_subscription][crate::model::RuntimeConfig::connd_subscription].
    pub fn set_connd_subscription<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.connd_subscription = v.into();
        self
    }

    /// Sets the value of [control_plane_topic][crate::model::RuntimeConfig::control_plane_topic].
    pub fn set_control_plane_topic<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.control_plane_topic = v.into();
        self
    }

    /// Sets the value of [control_plane_subscription][crate::model::RuntimeConfig::control_plane_subscription].
    pub fn set_control_plane_subscription<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.control_plane_subscription = v.into();
        self
    }

    /// Sets the value of [runtime_endpoint][crate::model::RuntimeConfig::runtime_endpoint].
    pub fn set_runtime_endpoint<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.runtime_endpoint = v.into();
        self
    }

    /// Sets the value of [state][crate::model::RuntimeConfig::state].
    pub fn set_state<T: std::convert::Into<crate::model::runtime_config::State>>(
        mut self,
        v: T,
    ) -> Self {
        self.state = v.into();
        self
    }

    /// Sets the value of [schema_gcs_bucket][crate::model::RuntimeConfig::schema_gcs_bucket].
    pub fn set_schema_gcs_bucket<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.schema_gcs_bucket = v.into();
        self
    }

    /// Sets the value of [service_directory][crate::model::RuntimeConfig::service_directory].
    pub fn set_service_directory<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.service_directory = v.into();
        self
    }

    /// Sets the value of [name][crate::model::RuntimeConfig::name].
    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 RuntimeConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.connectors.v1.RuntimeConfig"
    }
}

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

    /// State of the location.
    #[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
    pub struct State(std::borrow::Cow<'static, str>);

    impl State {
        /// Creates a new State instance.
        pub const fn new(v: &'static str) -> Self {
            Self(std::borrow::Cow::Borrowed(v))
        }

        /// Gets the enum value.
        pub fn value(&self) -> &str {
            &self.0
        }
    }

    /// Useful constants to work with [State](State)
    pub mod state {
        use super::State;

        /// STATE_UNSPECIFIED.
        pub const STATE_UNSPECIFIED: State = State::new("STATE_UNSPECIFIED");

        /// INACTIVE.
        pub const INACTIVE: State = State::new("INACTIVE");

        /// ACTIVATING.
        pub const ACTIVATING: State = State::new("ACTIVATING");

        /// ACTIVE.
        pub const ACTIVE: State = State::new("ACTIVE");

        /// CREATING.
        pub const CREATING: State = State::new("CREATING");

        /// DELETING.
        pub const DELETING: State = State::new("DELETING");

        /// UPDATING.
        pub const UPDATING: State = State::new("UPDATING");
    }

    impl std::convert::From<std::string::String> for State {
        fn from(value: std::string::String) -> Self {
            Self(std::borrow::Cow::Owned(value))
        }
    }
}

/// Request for [GetGlobalSettingsRequest].
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct GetGlobalSettingsRequest {
    /// Required. The resource name of the Settings.
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,
}

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

    /// Sets the value of [name][crate::model::GetGlobalSettingsRequest::name].
    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 GetGlobalSettingsRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.connectors.v1.GetGlobalSettingsRequest"
    }
}

/// Global Settings details.
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct Settings {
    /// Output only. Resource name of the Connection.
    /// Format: projects/{project}/locations/global/settings}
    #[serde(skip_serializing_if = "std::string::String::is_empty")]
    pub name: std::string::String,

    /// Optional. Flag indicates whether vpc-sc is enabled.
    pub vpcsc: bool,

    /// Output only. Flag indicates if user is in PayG model
    pub payg: bool,
}

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

    /// Sets the value of [name][crate::model::Settings::name].
    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 [vpcsc][crate::model::Settings::vpcsc].
    pub fn set_vpcsc<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.vpcsc = v.into();
        self
    }

    /// Sets the value of [payg][crate::model::Settings::payg].
    pub fn set_payg<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.payg = v.into();
        self
    }
}

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

/// Ssl config details of a connector version
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct SslConfigTemplate {
    /// Controls the ssl type for the given connector version
    pub ssl_type: crate::model::SslType,

    /// Boolean for determining if the connector version mandates TLS.
    pub is_tls_mandatory: bool,

    /// List of supported Server Cert Types
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub server_cert_type: std::vec::Vec<crate::model::CertType>,

    /// List of supported Client Cert Types
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub client_cert_type: std::vec::Vec<crate::model::CertType>,

    /// Any additional fields that need to be rendered
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub additional_variables: std::vec::Vec<crate::model::ConfigVariableTemplate>,
}

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

    /// Sets the value of [ssl_type][crate::model::SslConfigTemplate::ssl_type].
    pub fn set_ssl_type<T: std::convert::Into<crate::model::SslType>>(mut self, v: T) -> Self {
        self.ssl_type = v.into();
        self
    }

    /// Sets the value of [is_tls_mandatory][crate::model::SslConfigTemplate::is_tls_mandatory].
    pub fn set_is_tls_mandatory<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.is_tls_mandatory = v.into();
        self
    }

    /// Sets the value of [server_cert_type][crate::model::SslConfigTemplate::server_cert_type].
    pub fn set_server_cert_type<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::CertType>,
    {
        use std::iter::Iterator;
        self.server_cert_type = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [client_cert_type][crate::model::SslConfigTemplate::client_cert_type].
    pub fn set_client_cert_type<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::CertType>,
    {
        use std::iter::Iterator;
        self.client_cert_type = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [additional_variables][crate::model::SslConfigTemplate::additional_variables].
    pub fn set_additional_variables<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::ConfigVariableTemplate>,
    {
        use std::iter::Iterator;
        self.additional_variables = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

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

/// SSL Configuration of a connection
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default, rename_all = "camelCase")]
#[non_exhaustive]
pub struct SslConfig {
    /// Controls the ssl type for the given connector version.
    #[serde(rename = "type")]
    pub r#type: crate::model::SslType,

    /// Trust Model of the SSL connection
    pub trust_model: crate::model::ssl_config::TrustModel,

    /// Private Server Certificate. Needs to be specified if trust model is
    /// `PRIVATE`.
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub private_server_certificate: std::option::Option<crate::model::Secret>,

    /// Client Certificate
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub client_certificate: std::option::Option<crate::model::Secret>,

    /// Client Private Key
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub client_private_key: std::option::Option<crate::model::Secret>,

    /// Secret containing the passphrase protecting the Client Private Key
    #[serde(skip_serializing_if = "std::option::Option::is_none")]
    pub client_private_key_pass: std::option::Option<crate::model::Secret>,

    /// Type of Server Cert (PEM/JKS/.. etc.)
    pub server_cert_type: crate::model::CertType,

    /// Type of Client Cert (PEM/JKS/.. etc.)
    pub client_cert_type: crate::model::CertType,

    /// Bool for enabling SSL
    pub use_ssl: bool,

    /// Additional SSL related field values
    #[serde(skip_serializing_if = "std::vec::Vec::is_empty")]
    pub additional_variables: std::vec::Vec<crate::model::ConfigVariable>,
}

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

    /// Sets the value of [r#type][crate::model::SslConfig::type].
    pub fn set_type<T: std::convert::Into<crate::model::SslType>>(mut self, v: T) -> Self {
        self.r#type = v.into();
        self
    }

    /// Sets the value of [trust_model][crate::model::SslConfig::trust_model].
    pub fn set_trust_model<T: std::convert::Into<crate::model::ssl_config::TrustModel>>(
        mut self,
        v: T,
    ) -> Self {
        self.trust_model = v.into();
        self
    }

    /// Sets the value of [private_server_certificate][crate::model::SslConfig::private_server_certificate].
    pub fn set_private_server_certificate<
        T: std::convert::Into<std::option::Option<crate::model::Secret>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.private_server_certificate = v.into();
        self
    }

    /// Sets the value of [client_certificate][crate::model::SslConfig::client_certificate].
    pub fn set_client_certificate<
        T: std::convert::Into<std::option::Option<crate::model::Secret>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.client_certificate = v.into();
        self
    }

    /// Sets the value of [client_private_key][crate::model::SslConfig::client_private_key].
    pub fn set_client_private_key<
        T: std::convert::Into<std::option::Option<crate::model::Secret>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.client_private_key = v.into();
        self
    }

    /// Sets the value of [client_private_key_pass][crate::model::SslConfig::client_private_key_pass].
    pub fn set_client_private_key_pass<
        T: std::convert::Into<std::option::Option<crate::model::Secret>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.client_private_key_pass = v.into();
        self
    }

    /// Sets the value of [server_cert_type][crate::model::SslConfig::server_cert_type].
    pub fn set_server_cert_type<T: std::convert::Into<crate::model::CertType>>(
        mut self,
        v: T,
    ) -> Self {
        self.server_cert_type = v.into();
        self
    }

    /// Sets the value of [client_cert_type][crate::model::SslConfig::client_cert_type].
    pub fn set_client_cert_type<T: std::convert::Into<crate::model::CertType>>(
        mut self,
        v: T,
    ) -> Self {
        self.client_cert_type = v.into();
        self
    }

    /// Sets the value of [use_ssl][crate::model::SslConfig::use_ssl].
    pub fn set_use_ssl<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.use_ssl = v.into();
        self
    }

    /// Sets the value of [additional_variables][crate::model::SslConfig::additional_variables].
    pub fn set_additional_variables<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::ConfigVariable>,
    {
        use std::iter::Iterator;
        self.additional_variables = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

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

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

    /// Enum for Ttust Model
    #[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
    pub struct TrustModel(std::borrow::Cow<'static, str>);

    impl TrustModel {
        /// Creates a new TrustModel instance.
        pub const fn new(v: &'static str) -> Self {
            Self(std::borrow::Cow::Borrowed(v))
        }

        /// Gets the enum value.
        pub fn value(&self) -> &str {
            &self.0
        }
    }

    /// Useful constants to work with [TrustModel](TrustModel)
    pub mod trust_model {
        use super::TrustModel;

        /// Public Trust Model. Takes the Default Java trust store.
        pub const PUBLIC: TrustModel = TrustModel::new("PUBLIC");

        /// Private Trust Model. Takes custom/private trust store.
        pub const PRIVATE: TrustModel = TrustModel::new("PRIVATE");

        /// Insecure Trust Model. Accept all certificates.
        pub const INSECURE: TrustModel = TrustModel::new("INSECURE");
    }

    impl std::convert::From<std::string::String> for TrustModel {
        fn from(value: std::string::String) -> Self {
            Self(std::borrow::Cow::Owned(value))
        }
    }
}

/// AuthType defines different authentication types.
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
pub struct AuthType(std::borrow::Cow<'static, str>);

impl AuthType {
    /// Creates a new AuthType instance.
    pub const fn new(v: &'static str) -> Self {
        Self(std::borrow::Cow::Borrowed(v))
    }

    /// Gets the enum value.
    pub fn value(&self) -> &str {
        &self.0
    }
}

/// Useful constants to work with [AuthType](AuthType)
pub mod auth_type {
    use super::AuthType;

    /// Authentication type not specified.
    pub const AUTH_TYPE_UNSPECIFIED: AuthType = AuthType::new("AUTH_TYPE_UNSPECIFIED");

    /// Username and Password Authentication.
    pub const USER_PASSWORD: AuthType = AuthType::new("USER_PASSWORD");

    /// JSON Web Token (JWT) Profile for Oauth 2.0
    /// Authorization Grant based authentication
    pub const OAUTH2_JWT_BEARER: AuthType = AuthType::new("OAUTH2_JWT_BEARER");

    /// Oauth 2.0 Client Credentials Grant Authentication
    pub const OAUTH2_CLIENT_CREDENTIALS: AuthType = AuthType::new("OAUTH2_CLIENT_CREDENTIALS");

    /// SSH Public Key Authentication
    pub const SSH_PUBLIC_KEY: AuthType = AuthType::new("SSH_PUBLIC_KEY");

    /// Oauth 2.0 Authorization Code Flow
    pub const OAUTH2_AUTH_CODE_FLOW: AuthType = AuthType::new("OAUTH2_AUTH_CODE_FLOW");
}

impl std::convert::From<std::string::String> for AuthType {
    fn from(value: std::string::String) -> Self {
        Self(std::borrow::Cow::Owned(value))
    }
}

/// LaunchStage is a enum to indicate launch stage:
/// PREVIEW, GA, DEPRECATED, PRIVATE_PREVIEW.
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
pub struct LaunchStage(std::borrow::Cow<'static, str>);

impl LaunchStage {
    /// Creates a new LaunchStage instance.
    pub const fn new(v: &'static str) -> Self {
        Self(std::borrow::Cow::Borrowed(v))
    }

    /// Gets the enum value.
    pub fn value(&self) -> &str {
        &self.0
    }
}

/// Useful constants to work with [LaunchStage](LaunchStage)
pub mod launch_stage {
    use super::LaunchStage;

    /// LAUNCH_STAGE_UNSPECIFIED.
    pub const LAUNCH_STAGE_UNSPECIFIED: LaunchStage = LaunchStage::new("LAUNCH_STAGE_UNSPECIFIED");

    /// PREVIEW.
    pub const PREVIEW: LaunchStage = LaunchStage::new("PREVIEW");

    /// GA.
    pub const GA: LaunchStage = LaunchStage::new("GA");

    /// DEPRECATED.
    pub const DEPRECATED: LaunchStage = LaunchStage::new("DEPRECATED");

    /// PRIVATE_PREVIEW.
    pub const PRIVATE_PREVIEW: LaunchStage = LaunchStage::new("PRIVATE_PREVIEW");
}

impl std::convert::From<std::string::String> for LaunchStage {
    fn from(value: std::string::String) -> Self {
        Self(std::borrow::Cow::Owned(value))
    }
}

/// All possible data types of a entity or action field.
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
pub struct DataType(std::borrow::Cow<'static, str>);

impl DataType {
    /// Creates a new DataType instance.
    pub const fn new(v: &'static str) -> Self {
        Self(std::borrow::Cow::Borrowed(v))
    }

    /// Gets the enum value.
    pub fn value(&self) -> &str {
        &self.0
    }
}

/// Useful constants to work with [DataType](DataType)
pub mod data_type {
    use super::DataType;

    /// Data type is not specified.
    pub const DATA_TYPE_UNSPECIFIED: DataType = DataType::new("DATA_TYPE_UNSPECIFIED");

    /// DEPRECATED! Use DATA_TYPE_INTEGER.
    pub const DATA_TYPE_INT: DataType = DataType::new("DATA_TYPE_INT");

    /// Short integer(int16) data type.
    pub const DATA_TYPE_SMALLINT: DataType = DataType::new("DATA_TYPE_SMALLINT");

    /// Double data type.
    pub const DATA_TYPE_DOUBLE: DataType = DataType::new("DATA_TYPE_DOUBLE");

    /// Date data type.
    pub const DATA_TYPE_DATE: DataType = DataType::new("DATA_TYPE_DATE");

    /// DEPRECATED! Use DATA_TYPE_TIMESTAMP.
    pub const DATA_TYPE_DATETIME: DataType = DataType::new("DATA_TYPE_DATETIME");

    /// Time data type.
    pub const DATA_TYPE_TIME: DataType = DataType::new("DATA_TYPE_TIME");

    /// DEPRECATED! Use DATA_TYPE_VARCHAR.
    pub const DATA_TYPE_STRING: DataType = DataType::new("DATA_TYPE_STRING");

    /// DEPRECATED! Use DATA_TYPE_BIGINT.
    pub const DATA_TYPE_LONG: DataType = DataType::new("DATA_TYPE_LONG");

    /// Boolean data type.
    pub const DATA_TYPE_BOOLEAN: DataType = DataType::new("DATA_TYPE_BOOLEAN");

    /// Decimal data type.
    pub const DATA_TYPE_DECIMAL: DataType = DataType::new("DATA_TYPE_DECIMAL");

    /// DEPRECATED! Use DATA_TYPE_VARCHAR.
    pub const DATA_TYPE_UUID: DataType = DataType::new("DATA_TYPE_UUID");

    /// UNSUPPORTED! Binary data type.
    pub const DATA_TYPE_BLOB: DataType = DataType::new("DATA_TYPE_BLOB");

    /// Bit data type.
    pub const DATA_TYPE_BIT: DataType = DataType::new("DATA_TYPE_BIT");

    /// Small integer(int8) data type.
    pub const DATA_TYPE_TINYINT: DataType = DataType::new("DATA_TYPE_TINYINT");

    /// Integer(int32) data type.
    pub const DATA_TYPE_INTEGER: DataType = DataType::new("DATA_TYPE_INTEGER");

    /// Long integer(int64) data type.
    pub const DATA_TYPE_BIGINT: DataType = DataType::new("DATA_TYPE_BIGINT");

    /// Float data type.
    pub const DATA_TYPE_FLOAT: DataType = DataType::new("DATA_TYPE_FLOAT");

    /// Real data type.
    pub const DATA_TYPE_REAL: DataType = DataType::new("DATA_TYPE_REAL");

    /// Numeric data type.
    pub const DATA_TYPE_NUMERIC: DataType = DataType::new("DATA_TYPE_NUMERIC");

    /// Char data type.
    pub const DATA_TYPE_CHAR: DataType = DataType::new("DATA_TYPE_CHAR");

    /// Varchar data type.
    pub const DATA_TYPE_VARCHAR: DataType = DataType::new("DATA_TYPE_VARCHAR");

    /// Longvarchar data type.
    pub const DATA_TYPE_LONGVARCHAR: DataType = DataType::new("DATA_TYPE_LONGVARCHAR");

    /// Timestamp data type.
    pub const DATA_TYPE_TIMESTAMP: DataType = DataType::new("DATA_TYPE_TIMESTAMP");

    /// Nchar data type.
    pub const DATA_TYPE_NCHAR: DataType = DataType::new("DATA_TYPE_NCHAR");

    /// Nvarchar data type.
    pub const DATA_TYPE_NVARCHAR: DataType = DataType::new("DATA_TYPE_NVARCHAR");

    /// Longnvarchar data type.
    pub const DATA_TYPE_LONGNVARCHAR: DataType = DataType::new("DATA_TYPE_LONGNVARCHAR");

    /// Null data type.
    pub const DATA_TYPE_NULL: DataType = DataType::new("DATA_TYPE_NULL");

    /// UNSUPPORTED! Binary data type.
    pub const DATA_TYPE_OTHER: DataType = DataType::new("DATA_TYPE_OTHER");

    /// UNSUPPORTED! Binary data type.
    pub const DATA_TYPE_JAVA_OBJECT: DataType = DataType::new("DATA_TYPE_JAVA_OBJECT");

    /// UNSUPPORTED! Binary data type.
    pub const DATA_TYPE_DISTINCT: DataType = DataType::new("DATA_TYPE_DISTINCT");

    /// UNSUPPORTED! Binary data type.
    pub const DATA_TYPE_STRUCT: DataType = DataType::new("DATA_TYPE_STRUCT");

    /// UNSUPPORTED! Binary data type.
    pub const DATA_TYPE_ARRAY: DataType = DataType::new("DATA_TYPE_ARRAY");

    /// UNSUPPORTED! Binary data type.
    pub const DATA_TYPE_CLOB: DataType = DataType::new("DATA_TYPE_CLOB");

    /// UNSUPPORTED! Binary data type.
    pub const DATA_TYPE_REF: DataType = DataType::new("DATA_TYPE_REF");

    /// UNSUPPORTED! Binary data type.
    pub const DATA_TYPE_DATALINK: DataType = DataType::new("DATA_TYPE_DATALINK");

    /// UNSUPPORTED! Row id data type.
    pub const DATA_TYPE_ROWID: DataType = DataType::new("DATA_TYPE_ROWID");

    /// UNSUPPORTED! Binary data type.
    pub const DATA_TYPE_BINARY: DataType = DataType::new("DATA_TYPE_BINARY");

    /// UNSUPPORTED! Variable binary data type.
    pub const DATA_TYPE_VARBINARY: DataType = DataType::new("DATA_TYPE_VARBINARY");

    /// UNSUPPORTED! Long variable binary data type.
    pub const DATA_TYPE_LONGVARBINARY: DataType = DataType::new("DATA_TYPE_LONGVARBINARY");

    /// UNSUPPORTED! NCLOB data type.
    pub const DATA_TYPE_NCLOB: DataType = DataType::new("DATA_TYPE_NCLOB");

    /// UNSUPPORTED! SQL XML data type is not supported.
    pub const DATA_TYPE_SQLXML: DataType = DataType::new("DATA_TYPE_SQLXML");

    /// UNSUPPORTED! Cursor reference type is not supported.
    pub const DATA_TYPE_REF_CURSOR: DataType = DataType::new("DATA_TYPE_REF_CURSOR");

    /// UNSUPPORTED! Use TIME or TIMESTAMP instead.
    pub const DATA_TYPE_TIME_WITH_TIMEZONE: DataType =
        DataType::new("DATA_TYPE_TIME_WITH_TIMEZONE");

    /// UNSUPPORTED! Use TIMESTAMP instead.
    pub const DATA_TYPE_TIMESTAMP_WITH_TIMEZONE: DataType =
        DataType::new("DATA_TYPE_TIMESTAMP_WITH_TIMEZONE");
}

impl std::convert::From<std::string::String> for DataType {
    fn from(value: std::string::String) -> Self {
        Self(std::borrow::Cow::Owned(value))
    }
}

/// Enum to control which fields should be included in the response.
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
pub struct ConnectionView(std::borrow::Cow<'static, str>);

impl ConnectionView {
    /// Creates a new ConnectionView instance.
    pub const fn new(v: &'static str) -> Self {
        Self(std::borrow::Cow::Borrowed(v))
    }

    /// Gets the enum value.
    pub fn value(&self) -> &str {
        &self.0
    }
}

/// Useful constants to work with [ConnectionView](ConnectionView)
pub mod connection_view {
    use super::ConnectionView;

    /// CONNECTION_UNSPECIFIED.
    pub const CONNECTION_VIEW_UNSPECIFIED: ConnectionView =
        ConnectionView::new("CONNECTION_VIEW_UNSPECIFIED");

    /// Do not include runtime required configs.
    pub const BASIC: ConnectionView = ConnectionView::new("BASIC");

    /// Include runtime required configs.
    pub const FULL: ConnectionView = ConnectionView::new("FULL");
}

impl std::convert::From<std::string::String> for ConnectionView {
    fn from(value: std::string::String) -> Self {
        Self(std::borrow::Cow::Owned(value))
    }
}

/// Enum to control which fields should be included in the response.
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
pub struct ConnectorVersionView(std::borrow::Cow<'static, str>);

impl ConnectorVersionView {
    /// Creates a new ConnectorVersionView instance.
    pub const fn new(v: &'static str) -> Self {
        Self(std::borrow::Cow::Borrowed(v))
    }

    /// Gets the enum value.
    pub fn value(&self) -> &str {
        &self.0
    }
}

/// Useful constants to work with [ConnectorVersionView](ConnectorVersionView)
pub mod connector_version_view {
    use super::ConnectorVersionView;

    /// CONNECTOR_VERSION_VIEW_UNSPECIFIED.
    pub const CONNECTOR_VERSION_VIEW_UNSPECIFIED: ConnectorVersionView =
        ConnectorVersionView::new("CONNECTOR_VERSION_VIEW_UNSPECIFIED");

    /// Do not include role grant configs.
    pub const CONNECTOR_VERSION_VIEW_BASIC: ConnectorVersionView =
        ConnectorVersionView::new("CONNECTOR_VERSION_VIEW_BASIC");

    /// Include role grant configs.
    pub const CONNECTOR_VERSION_VIEW_FULL: ConnectorVersionView =
        ConnectorVersionView::new("CONNECTOR_VERSION_VIEW_FULL");
}

impl std::convert::From<std::string::String> for ConnectorVersionView {
    fn from(value: std::string::String) -> Self {
        Self(std::borrow::Cow::Owned(value))
    }
}

/// Enum for controlling the SSL Type (TLS/MTLS)
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
pub struct SslType(std::borrow::Cow<'static, str>);

impl SslType {
    /// Creates a new SslType instance.
    pub const fn new(v: &'static str) -> Self {
        Self(std::borrow::Cow::Borrowed(v))
    }

    /// Gets the enum value.
    pub fn value(&self) -> &str {
        &self.0
    }
}

/// Useful constants to work with [SslType](SslType)
pub mod ssl_type {
    use super::SslType;

    /// No SSL configuration required.
    pub const SSL_TYPE_UNSPECIFIED: SslType = SslType::new("SSL_TYPE_UNSPECIFIED");

    /// TLS Handshake
    pub const TLS: SslType = SslType::new("TLS");

    /// mutual TLS (MTLS) Handshake
    pub const MTLS: SslType = SslType::new("MTLS");
}

impl std::convert::From<std::string::String> for SslType {
    fn from(value: std::string::String) -> Self {
        Self(std::borrow::Cow::Owned(value))
    }
}

/// Enum for Cert Types
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
pub struct CertType(std::borrow::Cow<'static, str>);

impl CertType {
    /// Creates a new CertType instance.
    pub const fn new(v: &'static str) -> Self {
        Self(std::borrow::Cow::Borrowed(v))
    }

    /// Gets the enum value.
    pub fn value(&self) -> &str {
        &self.0
    }
}

/// Useful constants to work with [CertType](CertType)
pub mod cert_type {
    use super::CertType;

    /// Cert type unspecified.
    pub const CERT_TYPE_UNSPECIFIED: CertType = CertType::new("CERT_TYPE_UNSPECIFIED");

    /// Privacy Enhanced Mail (PEM) Type
    pub const PEM: CertType = CertType::new("PEM");
}

impl std::convert::From<std::string::String> for CertType {
    fn from(value: std::string::String) -> Self {
        Self(std::borrow::Cow::Owned(value))
    }
}