google_cloudevents/google/events/cloud/clouddms/v1/

mod.rs

// This file is @generated by prost-build.
/// SSL configuration information.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct SslConfig {
    /// Output only. The ssl config type according to 'client_key',
    /// 'client_certificate' and 'ca_certificate'.
    #[prost(enumeration = "ssl_config::SslType", tag = "1")]
    pub r#type: i32,
}
/// Nested message and enum types in `SslConfig`.
pub mod ssl_config {
    /// Specifies The kind of ssl configuration used.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum SslType {
        /// Unspecified.
        Unspecified = 0,
        /// Only 'ca_certificate' specified.
        ServerOnly = 1,
        /// Both server ('ca_certificate'), and client ('client_key',
        /// 'client_certificate') specified.
        ServerClient = 2,
    }
    impl SslType {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "SSL_TYPE_UNSPECIFIED",
                Self::ServerOnly => "SERVER_ONLY",
                Self::ServerClient => "SERVER_CLIENT",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "SSL_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "SERVER_ONLY" => Some(Self::ServerOnly),
                "SERVER_CLIENT" => Some(Self::ServerClient),
                _ => None,
            }
        }
    }
}
/// Specifies connection parameters required specifically for MySQL databases.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MySqlConnectionProfile {
    /// Required. The IP or hostname of the source MySQL database.
    #[prost(string, tag = "1")]
    pub host: ::prost::alloc::string::String,
    /// Required. The network port of the source MySQL database.
    #[prost(int32, tag = "2")]
    pub port: i32,
    /// Required. The username that Database Migration Service will use to connect
    /// to the database. The value is encrypted when stored in Database Migration
    /// Service.
    #[prost(string, tag = "3")]
    pub username: ::prost::alloc::string::String,
    /// Output only. Indicates If this connection profile password is stored.
    #[prost(bool, tag = "5")]
    pub password_set: bool,
    /// SSL configuration for the destination to connect to the source database.
    #[prost(message, optional, tag = "6")]
    pub ssl: ::core::option::Option<SslConfig>,
    /// If the source is a Cloud SQL database, use this field to
    /// provide the Cloud SQL instance ID of the source.
    #[prost(string, tag = "7")]
    pub cloud_sql_id: ::prost::alloc::string::String,
}
/// Specifies connection parameters required specifically for PostgreSQL
/// databases.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PostgreSqlConnectionProfile {
    /// Required. The IP or hostname of the source PostgreSQL database.
    #[prost(string, tag = "1")]
    pub host: ::prost::alloc::string::String,
    /// Required. The network port of the source PostgreSQL database.
    #[prost(int32, tag = "2")]
    pub port: i32,
    /// Required. The username that Database Migration Service will use to connect
    /// to the database. The value is encrypted when stored in Database Migration
    /// Service.
    #[prost(string, tag = "3")]
    pub username: ::prost::alloc::string::String,
    /// Output only. Indicates If this connection profile password is stored.
    #[prost(bool, tag = "5")]
    pub password_set: bool,
    /// SSL configuration for the destination to connect to the source database.
    #[prost(message, optional, tag = "6")]
    pub ssl: ::core::option::Option<SslConfig>,
    /// If the source is a Cloud SQL database, use this field to
    /// provide the Cloud SQL instance ID of the source.
    #[prost(string, tag = "7")]
    pub cloud_sql_id: ::prost::alloc::string::String,
    /// Output only. If the source is a Cloud SQL database, this field indicates
    /// the network architecture it's associated with.
    #[prost(enumeration = "NetworkArchitecture", tag = "8")]
    pub network_architecture: i32,
}
/// Specifies required connection parameters, and, optionally, the parameters
/// required to create a Cloud SQL destination database instance.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CloudSqlConnectionProfile {
    /// Output only. The Cloud SQL instance ID that this connection profile is
    /// associated with.
    #[prost(string, tag = "1")]
    pub cloud_sql_id: ::prost::alloc::string::String,
    /// Immutable. Metadata used to create the destination Cloud SQL database.
    #[prost(message, optional, tag = "2")]
    pub settings: ::core::option::Option<CloudSqlSettings>,
    /// Output only. The Cloud SQL database instance's private IP.
    #[prost(string, tag = "3")]
    pub private_ip: ::prost::alloc::string::String,
    /// Output only. The Cloud SQL database instance's public IP.
    #[prost(string, tag = "4")]
    pub public_ip: ::prost::alloc::string::String,
    /// Output only. The Cloud SQL database instance's additional (outgoing) public
    /// IP. Used when the Cloud SQL database availability type is REGIONAL (i.e.
    /// multiple zones / highly available).
    #[prost(string, tag = "5")]
    pub additional_public_ip: ::prost::alloc::string::String,
}
/// Specifies required connection parameters, and the parameters
/// required to create an AlloyDB destination cluster.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AlloyDbConnectionProfile {
    /// Required. The AlloyDB cluster ID that this connection profile is associated
    /// with.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Immutable. Metadata used to create the destination AlloyDB cluster.
    #[prost(message, optional, tag = "2")]
    pub settings: ::core::option::Option<AlloyDbSettings>,
}
/// An entry for an Access Control list.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SqlAclEntry {
    /// The allowlisted value for the access control list.
    #[prost(string, tag = "1")]
    pub value: ::prost::alloc::string::String,
    /// A label to identify this entry.
    #[prost(string, tag = "3")]
    pub label: ::prost::alloc::string::String,
    /// The access control entry entry expiration.
    #[prost(oneof = "sql_acl_entry::Expiration", tags = "10")]
    pub expiration: ::core::option::Option<sql_acl_entry::Expiration>,
}
/// Nested message and enum types in `SqlAclEntry`.
pub mod sql_acl_entry {
    /// The access control entry entry expiration.
    #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
    pub enum Expiration {
        /// The time when this access control entry expires in
        /// [RFC 3339](<https://tools.ietf.org/html/rfc3339>) format, for example:
        /// `2012-11-15T16:19:00.094Z`.
        #[prost(message, tag = "10")]
        ExpireTime(::prost_types::Timestamp),
    }
}
/// IP Management configuration.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SqlIpConfig {
    /// Whether the instance should be assigned an IPv4 address or not.
    #[prost(message, optional, tag = "1")]
    pub enable_ipv4: ::core::option::Option<bool>,
    /// The resource link for the VPC network from which the Cloud SQL instance is
    /// accessible for private IP. For example,
    /// `projects/myProject/global/networks/default`. This setting can
    /// be updated, but it cannot be removed after it is set.
    #[prost(string, tag = "2")]
    pub private_network: ::prost::alloc::string::String,
    /// Whether SSL connections over IP should be enforced or not.
    #[prost(message, optional, tag = "3")]
    pub require_ssl: ::core::option::Option<bool>,
    /// The list of external networks that are allowed to connect to the instance
    /// using the IP. See
    /// <https://en.wikipedia.org/wiki/CIDR_notation#CIDR_notation,> also known as
    /// 'slash' notation (e.g. `192.168.100.0/24`).
    #[prost(message, repeated, tag = "4")]
    pub authorized_networks: ::prost::alloc::vec::Vec<SqlAclEntry>,
}
/// Settings for creating a Cloud SQL database instance.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CloudSqlSettings {
    /// The database engine type and version.
    #[prost(enumeration = "cloud_sql_settings::SqlDatabaseVersion", tag = "1")]
    pub database_version: i32,
    /// The resource labels for a Cloud SQL instance to use to annotate any related
    /// underlying resources such as Compute Engine VMs.
    /// An object containing a list of "key": "value" pairs.
    ///
    /// Example: `{ "name": "wrench", "mass": "18kg", "count": "3" }`.
    #[prost(map = "string, string", tag = "2")]
    pub user_labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// The tier (or machine type) for this instance, for example:
    /// `db-n1-standard-1` (MySQL instances) or
    /// `db-custom-1-3840` (PostgreSQL instances).
    /// For more information, see
    /// [Cloud SQL Instance
    /// Settings](<https://cloud.google.com/sql/docs/mysql/instance-settings>).
    #[prost(string, tag = "3")]
    pub tier: ::prost::alloc::string::String,
    /// The maximum size to which storage capacity can be automatically increased.
    /// The default value is 0, which specifies that there is no limit.
    #[prost(message, optional, tag = "4")]
    pub storage_auto_resize_limit: ::core::option::Option<i64>,
    /// The activation policy specifies when the instance is activated; it is
    /// applicable only when the instance state is 'RUNNABLE'. Valid values:
    ///
    /// 'ALWAYS': The instance is on, and remains so even in
    /// the absence of connection requests.
    ///
    /// `NEVER`: The instance is off; it is not activated, even if a
    /// connection request arrives.
    #[prost(enumeration = "cloud_sql_settings::SqlActivationPolicy", tag = "5")]
    pub activation_policy: i32,
    /// The settings for IP Management. This allows to enable or disable the
    /// instance IP and manage which external networks can connect to the instance.
    /// The IPv4 address cannot be disabled.
    #[prost(message, optional, tag = "6")]
    pub ip_config: ::core::option::Option<SqlIpConfig>,
    /// \[default: ON\] If you enable this setting, Cloud SQL checks your available
    /// storage every 30 seconds. If the available storage falls below a threshold
    /// size, Cloud SQL automatically adds additional storage capacity. If the
    /// available storage repeatedly falls below the threshold size, Cloud SQL
    /// continues to add storage until it reaches the maximum of 30 TB.
    #[prost(message, optional, tag = "7")]
    pub auto_storage_increase: ::core::option::Option<bool>,
    /// The database flags passed to the Cloud SQL instance at startup.
    /// An object containing a list of "key": value pairs.
    /// Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
    #[prost(map = "string, string", tag = "8")]
    pub database_flags: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// The type of storage: `PD_SSD` (default) or `PD_HDD`.
    #[prost(enumeration = "cloud_sql_settings::SqlDataDiskType", tag = "9")]
    pub data_disk_type: i32,
    /// The storage capacity available to the database, in GB.
    /// The minimum (and default) size is 10GB.
    #[prost(message, optional, tag = "10")]
    pub data_disk_size_gb: ::core::option::Option<i64>,
    /// The Google Cloud Platform zone where your Cloud SQL database instance is
    /// located.
    #[prost(string, tag = "11")]
    pub zone: ::prost::alloc::string::String,
    /// Optional. The Google Cloud Platform zone where the failover Cloud SQL
    /// database instance is located. Used when the Cloud SQL database availability
    /// type is REGIONAL (i.e. multiple zones / highly available).
    #[prost(string, tag = "18")]
    pub secondary_zone: ::prost::alloc::string::String,
    /// The Database Migration Service source connection profile ID,
    /// in the format:
    /// `projects/my_project_name/locations/us-central1/connectionProfiles/connection_profile_ID`
    #[prost(string, tag = "12")]
    pub source_id: ::prost::alloc::string::String,
    /// Output only. Indicates If this connection profile root password is stored.
    #[prost(bool, tag = "14")]
    pub root_password_set: bool,
    /// The Cloud SQL default instance level collation.
    #[prost(string, tag = "15")]
    pub collation: ::prost::alloc::string::String,
    /// The KMS key name used for the csql instance.
    #[prost(string, tag = "16")]
    pub cmek_key_name: ::prost::alloc::string::String,
    /// Optional. Availability type. Potential values:
    /// *  `ZONAL`: The instance serves data from only one zone. Outages in that
    /// zone affect data availability.
    /// *  `REGIONAL`: The instance can serve data from more than one zone in a
    /// region (it is highly available).
    #[prost(enumeration = "cloud_sql_settings::SqlAvailabilityType", tag = "17")]
    pub availability_type: i32,
}
/// Nested message and enum types in `CloudSqlSettings`.
pub mod cloud_sql_settings {
    /// Specifies when the instance should be activated.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum SqlActivationPolicy {
        /// unspecified policy.
        Unspecified = 0,
        /// The instance is always up and running.
        Always = 1,
        /// The instance should never spin up.
        Never = 2,
    }
    impl SqlActivationPolicy {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "SQL_ACTIVATION_POLICY_UNSPECIFIED",
                Self::Always => "ALWAYS",
                Self::Never => "NEVER",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "SQL_ACTIVATION_POLICY_UNSPECIFIED" => Some(Self::Unspecified),
                "ALWAYS" => Some(Self::Always),
                "NEVER" => Some(Self::Never),
                _ => None,
            }
        }
    }
    /// The storage options for Cloud SQL databases.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum SqlDataDiskType {
        /// Unspecified.
        Unspecified = 0,
        /// SSD disk.
        PdSsd = 1,
        /// HDD disk.
        PdHdd = 2,
    }
    impl SqlDataDiskType {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "SQL_DATA_DISK_TYPE_UNSPECIFIED",
                Self::PdSsd => "PD_SSD",
                Self::PdHdd => "PD_HDD",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "SQL_DATA_DISK_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "PD_SSD" => Some(Self::PdSsd),
                "PD_HDD" => Some(Self::PdHdd),
                _ => None,
            }
        }
    }
    /// The database engine type and version.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum SqlDatabaseVersion {
        /// Unspecified version.
        Unspecified = 0,
        /// MySQL 5.6.
        Mysql56 = 1,
        /// MySQL 5.7.
        Mysql57 = 2,
        /// PostgreSQL 9.6.
        Postgres96 = 3,
        /// PostgreSQL 11.
        Postgres11 = 4,
        /// PostgreSQL 10.
        Postgres10 = 5,
        /// MySQL 8.0.
        Mysql80 = 6,
        /// PostgreSQL 12.
        Postgres12 = 7,
        /// PostgreSQL 13.
        Postgres13 = 8,
        /// PostgreSQL 14.
        Postgres14 = 17,
    }
    impl SqlDatabaseVersion {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "SQL_DATABASE_VERSION_UNSPECIFIED",
                Self::Mysql56 => "MYSQL_5_6",
                Self::Mysql57 => "MYSQL_5_7",
                Self::Postgres96 => "POSTGRES_9_6",
                Self::Postgres11 => "POSTGRES_11",
                Self::Postgres10 => "POSTGRES_10",
                Self::Mysql80 => "MYSQL_8_0",
                Self::Postgres12 => "POSTGRES_12",
                Self::Postgres13 => "POSTGRES_13",
                Self::Postgres14 => "POSTGRES_14",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "SQL_DATABASE_VERSION_UNSPECIFIED" => Some(Self::Unspecified),
                "MYSQL_5_6" => Some(Self::Mysql56),
                "MYSQL_5_7" => Some(Self::Mysql57),
                "POSTGRES_9_6" => Some(Self::Postgres96),
                "POSTGRES_11" => Some(Self::Postgres11),
                "POSTGRES_10" => Some(Self::Postgres10),
                "MYSQL_8_0" => Some(Self::Mysql80),
                "POSTGRES_12" => Some(Self::Postgres12),
                "POSTGRES_13" => Some(Self::Postgres13),
                "POSTGRES_14" => Some(Self::Postgres14),
                _ => None,
            }
        }
    }
    /// The availability type of the given Cloud SQL instance.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum SqlAvailabilityType {
        /// This is an unknown Availability type.
        Unspecified = 0,
        /// Zonal availablility instance.
        Zonal = 1,
        /// Regional availability instance.
        Regional = 2,
    }
    impl SqlAvailabilityType {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "SQL_AVAILABILITY_TYPE_UNSPECIFIED",
                Self::Zonal => "ZONAL",
                Self::Regional => "REGIONAL",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "SQL_AVAILABILITY_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "ZONAL" => Some(Self::Zonal),
                "REGIONAL" => Some(Self::Regional),
                _ => None,
            }
        }
    }
}
/// Settings for creating an AlloyDB cluster.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AlloyDbSettings {
    /// Required. The resource link for the VPC network in which cluster resources
    /// are created and from which they are accessible via Private IP. The network
    /// must belong to the same project as the cluster. It is specified in the
    /// form: "projects/{project_number}/global/networks/{network_id}". This is
    /// required to create a cluster.
    #[prost(string, tag = "2")]
    pub vpc_network: ::prost::alloc::string::String,
    /// Labels for the AlloyDB cluster created by DMS. An object containing a list
    /// of 'key', 'value' pairs.
    #[prost(map = "string, string", tag = "3")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    #[prost(message, optional, tag = "4")]
    pub primary_instance_settings: ::core::option::Option<
        alloy_db_settings::PrimaryInstanceSettings,
    >,
}
/// Nested message and enum types in `AlloyDbSettings`.
pub mod alloy_db_settings {
    /// The username/password for a database user. Used for specifying initial
    /// users at cluster creation time.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct UserPassword {
        /// The database username.
        #[prost(string, tag = "1")]
        pub user: ::prost::alloc::string::String,
        /// Output only. Indicates if the initial_user.password field has been set.
        #[prost(bool, tag = "3")]
        pub password_set: bool,
    }
    /// Settings for the cluster's primary instance
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct PrimaryInstanceSettings {
        /// Required. The ID of the AlloyDB primary instance. The ID must satisfy the
        /// regex expression "\[a-z0-9-\]+".
        #[prost(string, tag = "1")]
        pub id: ::prost::alloc::string::String,
        /// Configuration for the machines that host the underlying
        /// database engine.
        #[prost(message, optional, tag = "2")]
        pub machine_config: ::core::option::Option<
            primary_instance_settings::MachineConfig,
        >,
        /// Database flags to pass to AlloyDB when DMS is creating the AlloyDB
        /// cluster and instances. See the AlloyDB documentation for how these can be
        /// used.
        #[prost(map = "string, string", tag = "6")]
        pub database_flags: ::std::collections::HashMap<
            ::prost::alloc::string::String,
            ::prost::alloc::string::String,
        >,
        /// Labels for the AlloyDB primary instance created by DMS. An object
        /// containing a list of 'key', 'value' pairs.
        #[prost(map = "string, string", tag = "7")]
        pub labels: ::std::collections::HashMap<
            ::prost::alloc::string::String,
            ::prost::alloc::string::String,
        >,
        /// Output only. The private IP address for the Instance.
        /// This is the connection endpoint for an end-user application.
        #[prost(string, tag = "8")]
        pub private_ip: ::prost::alloc::string::String,
    }
    /// Nested message and enum types in `PrimaryInstanceSettings`.
    pub mod primary_instance_settings {
        /// MachineConfig describes the configuration of a machine.
        #[derive(Clone, Copy, PartialEq, ::prost::Message)]
        pub struct MachineConfig {
            /// The number of CPU's in the VM instance.
            #[prost(int32, tag = "1")]
            pub cpu_count: i32,
        }
    }
}
/// The source database will allow incoming connections from the destination
/// database's public IP. You can retrieve the Cloud SQL instance's public IP
/// from the Cloud SQL console or using Cloud SQL APIs. No additional
/// configuration is required.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct StaticIpConnectivity {}
/// The details needed to configure a reverse SSH tunnel between the source and
/// destination databases. These details will be used when calling the
/// generateSshScript method (see
/// <https://cloud.google.com/database-migration/docs/reference/rest/v1/projects.locations.migrationJobs/generateSshScript>)
/// to produce the script that will help set up the reverse SSH tunnel, and to
/// set up the VPC peering between the Cloud SQL private network and the VPC.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ReverseSshConnectivity {
    /// Required. The IP of the virtual machine (Compute Engine) used as the
    /// bastion server for the SSH tunnel.
    #[prost(string, tag = "1")]
    pub vm_ip: ::prost::alloc::string::String,
    /// Required. The forwarding port of the virtual machine (Compute Engine) used
    /// as the bastion server for the SSH tunnel.
    #[prost(int32, tag = "2")]
    pub vm_port: i32,
    /// The name of the virtual machine (Compute Engine) used as the bastion server
    /// for the SSH tunnel.
    #[prost(string, tag = "3")]
    pub vm: ::prost::alloc::string::String,
    /// The name of the VPC to peer with the Cloud SQL private network.
    #[prost(string, tag = "4")]
    pub vpc: ::prost::alloc::string::String,
}
/// The details of the VPC where the source database is located in Google Cloud.
/// We will use this information to set up the VPC peering connection between
/// Cloud SQL and this VPC.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct VpcPeeringConnectivity {
    /// The name of the VPC network to peer with the Cloud SQL private network.
    #[prost(string, tag = "1")]
    pub vpc: ::prost::alloc::string::String,
}
/// A message defining the database engine and provider.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct DatabaseType {
    /// The database provider.
    #[prost(enumeration = "DatabaseProvider", tag = "1")]
    pub provider: i32,
    /// The database engine.
    #[prost(enumeration = "DatabaseEngine", tag = "2")]
    pub engine: i32,
}
/// Represents a Database Migration Service migration job object.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MigrationJob {
    /// The name (URI) of this migration job resource, in the form of:
    /// projects/{project}/locations/{location}/migrationJobs/{migrationJob}.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. The timestamp when the migration job resource was created.
    /// A timestamp in RFC3339 UTC "Zulu" format, accurate to nanoseconds.
    /// Example: "2014-10-02T15:01:23.045123456Z".
    #[prost(message, optional, tag = "2")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The timestamp when the migration job resource was last
    /// updated. A timestamp in RFC3339 UTC "Zulu" format, accurate to nanoseconds.
    /// Example: "2014-10-02T15:01:23.045123456Z".
    #[prost(message, optional, tag = "3")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// The resource labels for migration job to use to annotate any related
    /// underlying resources such as Compute Engine VMs. An object containing a
    /// list of "key": "value" pairs.
    ///
    /// Example: `{ "name": "wrench", "mass": "1.3kg", "count": "3" }`.
    #[prost(map = "string, string", tag = "4")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// The migration job display name.
    #[prost(string, tag = "5")]
    pub display_name: ::prost::alloc::string::String,
    /// The current migration job state.
    #[prost(enumeration = "migration_job::State", tag = "6")]
    pub state: i32,
    /// Output only. The current migration job phase.
    #[prost(enumeration = "migration_job::Phase", tag = "7")]
    pub phase: i32,
    /// Required. The migration job type.
    #[prost(enumeration = "migration_job::Type", tag = "8")]
    pub r#type: i32,
    /// The path to the dump file in Google Cloud Storage,
    /// in the format: (gs://\[BUCKET_NAME\]/[OBJECT_NAME]).
    /// This field and the "dump_flags" field are mutually exclusive.
    #[prost(string, tag = "9")]
    pub dump_path: ::prost::alloc::string::String,
    /// The initial dump flags.
    /// This field and the "dump_path" field are mutually exclusive.
    #[prost(message, optional, tag = "17")]
    pub dump_flags: ::core::option::Option<migration_job::DumpFlags>,
    /// Required. The resource name (URI) of the source connection profile.
    #[prost(string, tag = "10")]
    pub source: ::prost::alloc::string::String,
    /// Required. The resource name (URI) of the destination connection profile.
    #[prost(string, tag = "11")]
    pub destination: ::prost::alloc::string::String,
    /// Output only. The duration of the migration job (in seconds). A duration in
    /// seconds with up to nine fractional digits, terminated by 's'. Example:
    /// "3.5s".
    #[prost(message, optional, tag = "12")]
    pub duration: ::core::option::Option<::prost_types::Duration>,
    /// Output only. The error details in case of state FAILED.
    #[prost(message, optional, tag = "13")]
    pub error: ::core::option::Option<super::super::super::super::rpc::Status>,
    /// The database engine type and provider of the source.
    #[prost(message, optional, tag = "14")]
    pub source_database: ::core::option::Option<DatabaseType>,
    /// The database engine type and provider of the destination.
    #[prost(message, optional, tag = "15")]
    pub destination_database: ::core::option::Option<DatabaseType>,
    /// Output only. If the migration job is completed, the time when it was
    /// completed.
    #[prost(message, optional, tag = "16")]
    pub end_time: ::core::option::Option<::prost_types::Timestamp>,
    /// The connectivity method.
    #[prost(oneof = "migration_job::Connectivity", tags = "101, 102, 103")]
    pub connectivity: ::core::option::Option<migration_job::Connectivity>,
}
/// Nested message and enum types in `MigrationJob`.
pub mod migration_job {
    /// Dump flag definition.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct DumpFlag {
        /// The name of the flag
        #[prost(string, tag = "1")]
        pub name: ::prost::alloc::string::String,
        /// The value of the flag.
        #[prost(string, tag = "2")]
        pub value: ::prost::alloc::string::String,
    }
    /// Dump flags definition.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct DumpFlags {
        /// The flags for the initial dump.
        #[prost(message, repeated, tag = "1")]
        pub dump_flags: ::prost::alloc::vec::Vec<DumpFlag>,
    }
    /// The current migration job states.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        /// The state of the migration job is unknown.
        Unspecified = 0,
        /// The migration job is down for maintenance.
        Maintenance = 1,
        /// The migration job is in draft mode and no resources are created.
        Draft = 2,
        /// The migration job is being created.
        Creating = 3,
        /// The migration job is created and not started.
        NotStarted = 4,
        /// The migration job is running.
        Running = 5,
        /// The migration job failed.
        Failed = 6,
        /// The migration job has been completed.
        Completed = 7,
        /// The migration job is being deleted.
        Deleting = 8,
        /// The migration job is being stopped.
        Stopping = 9,
        /// The migration job is currently stopped.
        Stopped = 10,
        /// The migration job has been deleted.
        Deleted = 11,
        /// The migration job is being updated.
        Updating = 12,
        /// The migration job is starting.
        Starting = 13,
        /// The migration job is restarting.
        Restarting = 14,
        /// The migration job is resuming.
        Resuming = 15,
    }
    impl State {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "STATE_UNSPECIFIED",
                Self::Maintenance => "MAINTENANCE",
                Self::Draft => "DRAFT",
                Self::Creating => "CREATING",
                Self::NotStarted => "NOT_STARTED",
                Self::Running => "RUNNING",
                Self::Failed => "FAILED",
                Self::Completed => "COMPLETED",
                Self::Deleting => "DELETING",
                Self::Stopping => "STOPPING",
                Self::Stopped => "STOPPED",
                Self::Deleted => "DELETED",
                Self::Updating => "UPDATING",
                Self::Starting => "STARTING",
                Self::Restarting => "RESTARTING",
                Self::Resuming => "RESUMING",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATE_UNSPECIFIED" => Some(Self::Unspecified),
                "MAINTENANCE" => Some(Self::Maintenance),
                "DRAFT" => Some(Self::Draft),
                "CREATING" => Some(Self::Creating),
                "NOT_STARTED" => Some(Self::NotStarted),
                "RUNNING" => Some(Self::Running),
                "FAILED" => Some(Self::Failed),
                "COMPLETED" => Some(Self::Completed),
                "DELETING" => Some(Self::Deleting),
                "STOPPING" => Some(Self::Stopping),
                "STOPPED" => Some(Self::Stopped),
                "DELETED" => Some(Self::Deleted),
                "UPDATING" => Some(Self::Updating),
                "STARTING" => Some(Self::Starting),
                "RESTARTING" => Some(Self::Restarting),
                "RESUMING" => Some(Self::Resuming),
                _ => None,
            }
        }
    }
    /// The current migration job phase.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Phase {
        /// The phase of the migration job is unknown.
        Unspecified = 0,
        /// The migration job is in the full dump phase.
        FullDump = 1,
        /// The migration job is CDC phase.
        Cdc = 2,
        /// The migration job is running the promote phase.
        PromoteInProgress = 3,
        /// Only RDS flow - waiting for source writes to stop
        WaitingForSourceWritesToStop = 4,
        /// Only RDS flow - the sources writes stopped, waiting for dump to begin
        PreparingTheDump = 5,
    }
    impl Phase {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "PHASE_UNSPECIFIED",
                Self::FullDump => "FULL_DUMP",
                Self::Cdc => "CDC",
                Self::PromoteInProgress => "PROMOTE_IN_PROGRESS",
                Self::WaitingForSourceWritesToStop => "WAITING_FOR_SOURCE_WRITES_TO_STOP",
                Self::PreparingTheDump => "PREPARING_THE_DUMP",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "PHASE_UNSPECIFIED" => Some(Self::Unspecified),
                "FULL_DUMP" => Some(Self::FullDump),
                "CDC" => Some(Self::Cdc),
                "PROMOTE_IN_PROGRESS" => Some(Self::PromoteInProgress),
                "WAITING_FOR_SOURCE_WRITES_TO_STOP" => {
                    Some(Self::WaitingForSourceWritesToStop)
                }
                "PREPARING_THE_DUMP" => Some(Self::PreparingTheDump),
                _ => None,
            }
        }
    }
    /// The type of migration job (one-time or continuous).
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Type {
        /// The type of the migration job is unknown.
        Unspecified = 0,
        /// The migration job is a one time migration.
        OneTime = 1,
        /// The migration job is a continuous migration.
        Continuous = 2,
    }
    impl Type {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "TYPE_UNSPECIFIED",
                Self::OneTime => "ONE_TIME",
                Self::Continuous => "CONTINUOUS",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "ONE_TIME" => Some(Self::OneTime),
                "CONTINUOUS" => Some(Self::Continuous),
                _ => None,
            }
        }
    }
    /// The connectivity method.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Connectivity {
        /// The details needed to communicate to the source over Reverse SSH
        /// tunnel connectivity.
        #[prost(message, tag = "101")]
        ReverseSshConnectivity(super::ReverseSshConnectivity),
        /// The details of the VPC network that the source database is located in.
        #[prost(message, tag = "102")]
        VpcPeeringConnectivity(super::VpcPeeringConnectivity),
        /// static ip connectivity data (default, no additional details needed).
        #[prost(message, tag = "103")]
        StaticIpConnectivity(super::StaticIpConnectivity),
    }
}
/// A connection profile definition.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ConnectionProfile {
    /// The name of this connection profile resource in the form of
    /// projects/{project}/locations/{location}/connectionProfiles/{connectionProfile}.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. The timestamp when the resource was created.
    /// A timestamp in RFC3339 UTC "Zulu" format, accurate to nanoseconds.
    /// Example: "2014-10-02T15:01:23.045123456Z".
    #[prost(message, optional, tag = "2")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The timestamp when the resource was last updated.
    /// A timestamp in RFC3339 UTC "Zulu" format, accurate to nanoseconds.
    /// Example: "2014-10-02T15:01:23.045123456Z".
    #[prost(message, optional, tag = "3")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// The resource labels for connection profile to use to annotate any related
    /// underlying resources such as Compute Engine VMs. An object containing a
    /// list of "key": "value" pairs.
    ///
    /// Example: `{ "name": "wrench", "mass": "1.3kg", "count": "3" }`.
    #[prost(map = "string, string", tag = "4")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// The current connection profile state (e.g. DRAFT, READY, or FAILED).
    #[prost(enumeration = "connection_profile::State", tag = "5")]
    pub state: i32,
    /// The connection profile display name.
    #[prost(string, tag = "6")]
    pub display_name: ::prost::alloc::string::String,
    /// Output only. The error details in case of state FAILED.
    #[prost(message, optional, tag = "7")]
    pub error: ::core::option::Option<super::super::super::super::rpc::Status>,
    /// The database provider.
    #[prost(enumeration = "DatabaseProvider", tag = "8")]
    pub provider: i32,
    /// The connection profile definition.
    #[prost(
        oneof = "connection_profile::ConnectionProfile",
        tags = "100, 101, 102, 105"
    )]
    pub connection_profile: ::core::option::Option<
        connection_profile::ConnectionProfile,
    >,
}
/// Nested message and enum types in `ConnectionProfile`.
pub mod connection_profile {
    /// The current connection profile state (e.g. DRAFT, READY, or FAILED).
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        /// The state of the connection profile is unknown.
        Unspecified = 0,
        /// The connection profile is in draft mode and fully editable.
        Draft = 1,
        /// The connection profile is being created.
        Creating = 2,
        /// The connection profile is ready.
        Ready = 3,
        /// The connection profile is being updated.
        Updating = 4,
        /// The connection profile is being deleted.
        Deleting = 5,
        /// The connection profile has been deleted.
        Deleted = 6,
        /// The last action on the connection profile failed.
        Failed = 7,
    }
    impl State {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "STATE_UNSPECIFIED",
                Self::Draft => "DRAFT",
                Self::Creating => "CREATING",
                Self::Ready => "READY",
                Self::Updating => "UPDATING",
                Self::Deleting => "DELETING",
                Self::Deleted => "DELETED",
                Self::Failed => "FAILED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATE_UNSPECIFIED" => Some(Self::Unspecified),
                "DRAFT" => Some(Self::Draft),
                "CREATING" => Some(Self::Creating),
                "READY" => Some(Self::Ready),
                "UPDATING" => Some(Self::Updating),
                "DELETING" => Some(Self::Deleting),
                "DELETED" => Some(Self::Deleted),
                "FAILED" => Some(Self::Failed),
                _ => None,
            }
        }
    }
    /// The connection profile definition.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum ConnectionProfile {
        /// A MySQL database connection profile.
        #[prost(message, tag = "100")]
        Mysql(super::MySqlConnectionProfile),
        /// A PostgreSQL database connection profile.
        #[prost(message, tag = "101")]
        Postgresql(super::PostgreSqlConnectionProfile),
        /// A CloudSQL database connection profile.
        #[prost(message, tag = "102")]
        Cloudsql(super::CloudSqlConnectionProfile),
        /// An AlloyDB cluster connection profile.
        #[prost(message, tag = "105")]
        Alloydb(super::AlloyDbConnectionProfile),
    }
}
/// The data within all ConnectionProfile events.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ConnectionProfileEventData {
    /// Optional. The ConnectionProfile event payload. Unset for deletion events.
    #[prost(message, optional, tag = "1")]
    pub payload: ::core::option::Option<ConnectionProfile>,
}
/// The data within all MigrationJob events.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MigrationJobEventData {
    /// Optional. The MigrationJob event payload. Unset for deletion events.
    #[prost(message, optional, tag = "1")]
    pub payload: ::core::option::Option<MigrationJob>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum NetworkArchitecture {
    Unspecified = 0,
    /// Instance is in Cloud SQL's old producer network architecture.
    OldCsqlProducer = 1,
    /// Instance is in Cloud SQL's new producer network architecture.
    NewCsqlProducer = 2,
}
impl NetworkArchitecture {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "NETWORK_ARCHITECTURE_UNSPECIFIED",
            Self::OldCsqlProducer => "NETWORK_ARCHITECTURE_OLD_CSQL_PRODUCER",
            Self::NewCsqlProducer => "NETWORK_ARCHITECTURE_NEW_CSQL_PRODUCER",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "NETWORK_ARCHITECTURE_UNSPECIFIED" => Some(Self::Unspecified),
            "NETWORK_ARCHITECTURE_OLD_CSQL_PRODUCER" => Some(Self::OldCsqlProducer),
            "NETWORK_ARCHITECTURE_NEW_CSQL_PRODUCER" => Some(Self::NewCsqlProducer),
            _ => None,
        }
    }
}
/// The database engine types.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum DatabaseEngine {
    /// The source database engine of the migration job is unknown.
    Unspecified = 0,
    /// The source engine is MySQL.
    Mysql = 1,
    /// The source engine is PostgreSQL.
    Postgresql = 2,
}
impl DatabaseEngine {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "DATABASE_ENGINE_UNSPECIFIED",
            Self::Mysql => "MYSQL",
            Self::Postgresql => "POSTGRESQL",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "DATABASE_ENGINE_UNSPECIFIED" => Some(Self::Unspecified),
            "MYSQL" => Some(Self::Mysql),
            "POSTGRESQL" => Some(Self::Postgresql),
            _ => None,
        }
    }
}
/// The database providers.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum DatabaseProvider {
    /// The database provider is unknown.
    Unspecified = 0,
    /// CloudSQL runs the database.
    Cloudsql = 1,
    /// RDS runs the database.
    Rds = 2,
    /// Amazon Aurora.
    Aurora = 3,
    /// AlloyDB.
    Alloydb = 4,
}
impl DatabaseProvider {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "DATABASE_PROVIDER_UNSPECIFIED",
            Self::Cloudsql => "CLOUDSQL",
            Self::Rds => "RDS",
            Self::Aurora => "AURORA",
            Self::Alloydb => "ALLOYDB",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "DATABASE_PROVIDER_UNSPECIFIED" => Some(Self::Unspecified),
            "CLOUDSQL" => Some(Self::Cloudsql),
            "RDS" => Some(Self::Rds),
            "AURORA" => Some(Self::Aurora),
            "ALLOYDB" => Some(Self::Alloydb),
            _ => None,
        }
    }
}
/// The CloudEvent raised when a MigrationJob is created.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MigrationJobCreatedEvent {
    /// The data associated with the event.
    #[prost(message, optional, tag = "1")]
    pub data: ::core::option::Option<MigrationJobEventData>,
}
/// The CloudEvent raised when a MigrationJob is updated.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MigrationJobUpdatedEvent {
    /// The data associated with the event.
    #[prost(message, optional, tag = "1")]
    pub data: ::core::option::Option<MigrationJobEventData>,
}
/// The CloudEvent raised when a MigrationJob is deleted.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MigrationJobDeletedEvent {
    /// The data associated with the event.
    #[prost(message, optional, tag = "1")]
    pub data: ::core::option::Option<MigrationJobEventData>,
}
/// The CloudEvent raised when a ConnectionProfile is created.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ConnectionProfileCreatedEvent {
    /// The data associated with the event.
    #[prost(message, optional, tag = "1")]
    pub data: ::core::option::Option<ConnectionProfileEventData>,
}
/// The CloudEvent raised when a ConnectionProfile is updated.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ConnectionProfileUpdatedEvent {
    /// The data associated with the event.
    #[prost(message, optional, tag = "1")]
    pub data: ::core::option::Option<ConnectionProfileEventData>,
}
/// The CloudEvent raised when a ConnectionProfile is deleted.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ConnectionProfileDeletedEvent {
    /// The data associated with the event.
    #[prost(message, optional, tag = "1")]
    pub data: ::core::option::Option<ConnectionProfileEventData>,
}