yandex-cloud 2025.4.14

#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AltName {
    /// Source table name
    #[prost(string, tag = "1")]
    pub from_name: ::prost::alloc::string::String,
    /// Target table name
    #[prost(string, tag = "2")]
    pub to_name: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Secret {
    #[prost(oneof = "secret::Value", tags = "1")]
    pub value: ::core::option::Option<secret::Value>,
}
/// Nested message and enum types in `Secret`.
pub mod secret {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Value {
        /// Raw secret value
        #[prost(string, tag = "1")]
        Raw(::prost::alloc::string::String),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ColSchema {
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    #[prost(enumeration = "ColumnType", tag = "2")]
    pub r#type: i32,
    #[prost(bool, tag = "3")]
    pub key: bool,
    #[prost(bool, tag = "4")]
    pub required: bool,
    #[prost(string, tag = "5")]
    pub path: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TlsMode {
    #[prost(oneof = "tls_mode::TlsMode", tags = "1, 2")]
    pub tls_mode: ::core::option::Option<tls_mode::TlsMode>,
}
/// Nested message and enum types in `TLSMode`.
pub mod tls_mode {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum TlsMode {
        #[prost(message, tag = "1")]
        Disabled(()),
        #[prost(message, tag = "2")]
        Enabled(super::TlsConfig),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TlsConfig {
    /// CA certificate
    ///
    /// X.509 certificate of the certificate authority which issued the server's
    /// certificate, in PEM format. When CA certificate is specified TLS is used to
    /// connect to the server.
    #[prost(string, tag = "1")]
    pub ca_certificate: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ColumnValue {
    #[prost(oneof = "column_value::Value", tags = "1")]
    pub value: ::core::option::Option<column_value::Value>,
}
/// Nested message and enum types in `ColumnValue`.
pub mod column_value {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Value {
        #[prost(string, tag = "1")]
        StringValue(::prost::alloc::string::String),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DataTransformationOptions {
    /// Cloud function
    #[prost(string, tag = "1")]
    pub cloud_function: ::prost::alloc::string::String,
    /// Number of retries
    #[prost(int64, tag = "2")]
    pub number_of_retries: i64,
    /// Buffer size for function
    #[prost(string, tag = "3")]
    pub buffer_size: ::prost::alloc::string::String,
    /// Flush interval
    #[prost(string, tag = "4")]
    pub buffer_flush_interval: ::prost::alloc::string::String,
    /// Invocation timeout
    #[prost(string, tag = "5")]
    pub invocation_timeout: ::prost::alloc::string::String,
    /// Service account
    #[prost(string, tag = "8")]
    pub service_account_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FieldList {
    /// Column schema
    #[prost(message, repeated, tag = "2")]
    pub fields: ::prost::alloc::vec::Vec<ColSchema>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DataSchema {
    #[prost(oneof = "data_schema::Schema", tags = "1, 2")]
    pub schema: ::core::option::Option<data_schema::Schema>,
}
/// Nested message and enum types in `DataSchema`.
pub mod data_schema {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Schema {
        #[prost(string, tag = "1")]
        JsonFields(::prost::alloc::string::String),
        #[prost(message, tag = "2")]
        Fields(super::FieldList),
    }
}
/// No authentication
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NoAuth {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ConnectionManagerConnection {
    #[prost(string, tag = "1")]
    pub connection_id: ::prost::alloc::string::String,
    /// Network interface for endpoint. If none will assume public ipv4
    #[prost(string, tag = "2")]
    pub subnet_id: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ObjectTransferStage {
    Unspecified = 0,
    /// Before data transfer
    BeforeData = 1,
    /// After data transfer
    AfterData = 2,
    /// Don't copy
    Never = 3,
}
impl ObjectTransferStage {
    /// 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 {
            ObjectTransferStage::Unspecified => "OBJECT_TRANSFER_STAGE_UNSPECIFIED",
            ObjectTransferStage::BeforeData => "BEFORE_DATA",
            ObjectTransferStage::AfterData => "AFTER_DATA",
            ObjectTransferStage::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 {
            "OBJECT_TRANSFER_STAGE_UNSPECIFIED" => Some(Self::Unspecified),
            "BEFORE_DATA" => Some(Self::BeforeData),
            "AFTER_DATA" => Some(Self::AfterData),
            "NEVER" => Some(Self::Never),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum CleanupPolicy {
    Unspecified = 0,
    /// Don't cleanup
    Disabled = 1,
    /// Drop
    Drop = 2,
    /// Truncate
    Truncate = 3,
}
impl CleanupPolicy {
    /// 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 {
            CleanupPolicy::Unspecified => "CLEANUP_POLICY_UNSPECIFIED",
            CleanupPolicy::Disabled => "DISABLED",
            CleanupPolicy::Drop => "DROP",
            CleanupPolicy::Truncate => "TRUNCATE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "CLEANUP_POLICY_UNSPECIFIED" => Some(Self::Unspecified),
            "DISABLED" => Some(Self::Disabled),
            "DROP" => Some(Self::Drop),
            "TRUNCATE" => Some(Self::Truncate),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ColumnType {
    Unspecified = 0,
    Int32 = 1,
    Int16 = 2,
    Int8 = 3,
    Uint64 = 4,
    Uint32 = 5,
    Uint16 = 6,
    Uint8 = 7,
    Double = 8,
    Boolean = 9,
    String = 10,
    Utf8 = 11,
    Any = 12,
    Datetime = 13,
    Int64 = 14,
}
impl ColumnType {
    /// 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 {
            ColumnType::Unspecified => "COLUMN_TYPE_UNSPECIFIED",
            ColumnType::Int32 => "INT32",
            ColumnType::Int16 => "INT16",
            ColumnType::Int8 => "INT8",
            ColumnType::Uint64 => "UINT64",
            ColumnType::Uint32 => "UINT32",
            ColumnType::Uint16 => "UINT16",
            ColumnType::Uint8 => "UINT8",
            ColumnType::Double => "DOUBLE",
            ColumnType::Boolean => "BOOLEAN",
            ColumnType::String => "STRING",
            ColumnType::Utf8 => "UTF8",
            ColumnType::Any => "ANY",
            ColumnType::Datetime => "DATETIME",
            ColumnType::Int64 => "INT64",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "COLUMN_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
            "INT32" => Some(Self::Int32),
            "INT16" => Some(Self::Int16),
            "INT8" => Some(Self::Int8),
            "UINT64" => Some(Self::Uint64),
            "UINT32" => Some(Self::Uint32),
            "UINT16" => Some(Self::Uint16),
            "UINT8" => Some(Self::Uint8),
            "DOUBLE" => Some(Self::Double),
            "BOOLEAN" => Some(Self::Boolean),
            "STRING" => Some(Self::String),
            "UTF8" => Some(Self::Utf8),
            "ANY" => Some(Self::Any),
            "DATETIME" => Some(Self::Datetime),
            "INT64" => Some(Self::Int64),
            _ => None,
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ClickhouseShard {
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    #[prost(string, repeated, tag = "2")]
    pub hosts: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OnPremiseClickhouse {
    #[prost(message, repeated, tag = "1")]
    pub shards: ::prost::alloc::vec::Vec<ClickhouseShard>,
    #[prost(int64, tag = "3")]
    pub http_port: i64,
    #[prost(int64, tag = "4")]
    pub native_port: i64,
    #[prost(message, optional, tag = "8")]
    pub tls_mode: ::core::option::Option<TlsMode>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ClickhouseConnectionOptions {
    #[prost(string, tag = "6")]
    pub user: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "7")]
    pub password: ::core::option::Option<Secret>,
    /// Database
    #[prost(string, tag = "8")]
    pub database: ::prost::alloc::string::String,
    #[prost(oneof = "clickhouse_connection_options::Address", tags = "2, 5")]
    pub address: ::core::option::Option<clickhouse_connection_options::Address>,
}
/// Nested message and enum types in `ClickhouseConnectionOptions`.
pub mod clickhouse_connection_options {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Address {
        #[prost(message, tag = "2")]
        OnPremise(super::OnPremiseClickhouse),
        #[prost(string, tag = "5")]
        MdbClusterId(::prost::alloc::string::String),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ClickhouseConnection {
    #[prost(oneof = "clickhouse_connection::Connection", tags = "1")]
    pub connection: ::core::option::Option<clickhouse_connection::Connection>,
}
/// Nested message and enum types in `ClickhouseConnection`.
pub mod clickhouse_connection {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Connection {
        #[prost(message, tag = "1")]
        ConnectionOptions(super::ClickhouseConnectionOptions),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ClickhouseSharding {
    #[prost(oneof = "clickhouse_sharding::Sharding", tags = "1, 2, 3, 4")]
    pub sharding: ::core::option::Option<clickhouse_sharding::Sharding>,
}
/// Nested message and enum types in `ClickhouseSharding`.
pub mod clickhouse_sharding {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ColumnValueHash {
        #[prost(string, tag = "1")]
        pub column_name: ::prost::alloc::string::String,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ColumnValueMapping {
        #[prost(string, tag = "1")]
        pub column_name: ::prost::alloc::string::String,
        #[prost(message, repeated, tag = "2")]
        pub mapping: ::prost::alloc::vec::Vec<column_value_mapping::ValueToShard>,
    }
    /// Nested message and enum types in `ColumnValueMapping`.
    pub mod column_value_mapping {
        #[allow(clippy::derive_partial_eq_without_eq)]
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct ValueToShard {
            #[prost(message, optional, tag = "1")]
            pub column_value: ::core::option::Option<super::super::ColumnValue>,
            #[prost(string, tag = "2")]
            pub shard_name: ::prost::alloc::string::String,
        }
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Sharding {
        #[prost(message, tag = "1")]
        ColumnValueHash(ColumnValueHash),
        #[prost(message, tag = "2")]
        CustomMapping(ColumnValueMapping),
        #[prost(message, tag = "3")]
        TransferId(()),
        #[prost(message, tag = "4")]
        RoundRobin(()),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ClickhouseSource {
    #[prost(message, optional, tag = "1")]
    pub connection: ::core::option::Option<ClickhouseConnection>,
    /// White list of tables for replication. If none or empty list is presented - will
    /// replicate all tables. Can contain * patterns.
    #[prost(string, repeated, tag = "7")]
    pub include_tables: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Exclude list of tables for replication. If none or empty list is presented -
    /// will replicate all tables. Can contain * patterns.
    #[prost(string, repeated, tag = "8")]
    pub exclude_tables: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(string, tag = "9")]
    pub subnet_id: ::prost::alloc::string::String,
    #[prost(string, repeated, tag = "10")]
    pub security_groups: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Name of the ClickHouse cluster. For Managed ClickHouse that is name of
    /// ShardGroup.
    #[prost(string, tag = "11")]
    pub clickhouse_cluster_name: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ClickhouseTarget {
    #[prost(message, optional, tag = "2")]
    pub connection: ::core::option::Option<ClickhouseConnection>,
    #[prost(string, tag = "12")]
    pub subnet_id: ::prost::alloc::string::String,
    /// Alternative table names in target
    #[prost(message, repeated, tag = "17")]
    pub alt_names: ::prost::alloc::vec::Vec<AltName>,
    #[prost(enumeration = "ClickhouseCleanupPolicy", tag = "21")]
    pub cleanup_policy: i32,
    #[prost(message, optional, tag = "22")]
    pub sharding: ::core::option::Option<ClickhouseSharding>,
    /// Name of the ClickHouse cluster. For Managed ClickHouse that is name of
    /// ShardGroup.
    #[prost(string, tag = "50")]
    pub clickhouse_cluster_name: ::prost::alloc::string::String,
    #[prost(string, repeated, tag = "51")]
    pub security_groups: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ClickhouseCleanupPolicy {
    Unspecified = 0,
    Disabled = 1,
    Drop = 2,
    Truncate = 3,
}
impl ClickhouseCleanupPolicy {
    /// 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 {
            ClickhouseCleanupPolicy::Unspecified => {
                "CLICKHOUSE_CLEANUP_POLICY_UNSPECIFIED"
            }
            ClickhouseCleanupPolicy::Disabled => "CLICKHOUSE_CLEANUP_POLICY_DISABLED",
            ClickhouseCleanupPolicy::Drop => "CLICKHOUSE_CLEANUP_POLICY_DROP",
            ClickhouseCleanupPolicy::Truncate => "CLICKHOUSE_CLEANUP_POLICY_TRUNCATE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "CLICKHOUSE_CLEANUP_POLICY_UNSPECIFIED" => Some(Self::Unspecified),
            "CLICKHOUSE_CLEANUP_POLICY_DISABLED" => Some(Self::Disabled),
            "CLICKHOUSE_CLEANUP_POLICY_DROP" => Some(Self::Drop),
            "CLICKHOUSE_CLEANUP_POLICY_TRUNCATE" => Some(Self::Truncate),
            _ => None,
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Parser {
    #[prost(oneof = "parser::Parser", tags = "1, 2, 4, 6")]
    pub parser: ::core::option::Option<parser::Parser>,
}
/// Nested message and enum types in `Parser`.
pub mod parser {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Parser {
        #[prost(message, tag = "1")]
        JsonParser(super::GenericParserCommon),
        #[prost(message, tag = "2")]
        AuditTrailsV1Parser(super::AuditTrailsV1Parser),
        #[prost(message, tag = "4")]
        CloudLoggingParser(super::CloudLoggingParser),
        #[prost(message, tag = "6")]
        TskvParser(super::GenericParserCommon),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GenericParserCommon {
    #[prost(message, optional, tag = "1")]
    pub data_schema: ::core::option::Option<DataSchema>,
    /// Allow null keys, if no - null keys will be putted to unparsed data
    #[prost(bool, tag = "2")]
    pub null_keys_allowed: bool,
    /// Will add _rest column for all unknown fields
    #[prost(bool, tag = "3")]
    pub add_rest_column: bool,
    /// Unescape string values
    #[prost(bool, tag = "7")]
    pub unescape_string_values: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AuditTrailsV1Parser {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CloudLoggingParser {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SerializerAuto {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SerializerJson {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DebeziumSerializerParameter {
    /// Name of the serializer parameter
    #[prost(string, tag = "1")]
    pub key: ::prost::alloc::string::String,
    /// Value of the serializer parameter
    #[prost(string, tag = "2")]
    pub value: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SerializerDebezium {
    /// Settings of sterilization parameters as key-value pairs
    #[prost(message, repeated, tag = "1")]
    pub serializer_parameters: ::prost::alloc::vec::Vec<DebeziumSerializerParameter>,
}
/// Data serialization format
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Serializer {
    #[prost(oneof = "serializer::Serializer", tags = "1, 2, 3")]
    pub serializer: ::core::option::Option<serializer::Serializer>,
}
/// Nested message and enum types in `Serializer`.
pub mod serializer {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Serializer {
        /// Select the serialization format automatically
        #[prost(message, tag = "1")]
        SerializerAuto(super::SerializerAuto),
        /// Serialize data in json format
        #[prost(message, tag = "2")]
        SerializerJson(super::SerializerJson),
        /// Serialize data in debezium format
        #[prost(message, tag = "3")]
        SerializerDebezium(super::SerializerDebezium),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct KafkaConnectionOptions {
    #[prost(oneof = "kafka_connection_options::Connection", tags = "1, 2")]
    pub connection: ::core::option::Option<kafka_connection_options::Connection>,
}
/// Nested message and enum types in `KafkaConnectionOptions`.
pub mod kafka_connection_options {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Connection {
        /// Managed Service for Kafka cluster ID
        #[prost(string, tag = "1")]
        ClusterId(::prost::alloc::string::String),
        /// Connection options for on-premise Kafka
        #[prost(message, tag = "2")]
        OnPremise(super::OnPremiseKafka),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OnPremiseKafka {
    /// Kafka broker URLs
    #[prost(string, repeated, tag = "1")]
    pub broker_urls: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Network interface for endpoint. If none will assume public ipv4
    #[prost(string, tag = "4")]
    pub subnet_id: ::prost::alloc::string::String,
    /// TLS settings for broker connection. Disabled by default.
    #[prost(message, optional, tag = "5")]
    pub tls_mode: ::core::option::Option<TlsMode>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct KafkaAuth {
    #[prost(oneof = "kafka_auth::Security", tags = "1, 2")]
    pub security: ::core::option::Option<kafka_auth::Security>,
}
/// Nested message and enum types in `KafkaAuth`.
pub mod kafka_auth {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Security {
        /// Authentication with SASL
        #[prost(message, tag = "1")]
        Sasl(super::KafkaSaslSecurity),
        /// No authentication
        #[prost(message, tag = "2")]
        NoAuth(super::NoAuth),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct KafkaSaslSecurity {
    /// User name
    #[prost(string, tag = "1")]
    pub user: ::prost::alloc::string::String,
    /// SASL mechanism for authentication
    #[prost(enumeration = "KafkaMechanism", tag = "3")]
    pub mechanism: i32,
    /// Password for user
    #[prost(message, optional, tag = "4")]
    pub password: ::core::option::Option<Secret>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct KafkaSource {
    /// Connection settings
    #[prost(message, optional, tag = "1")]
    pub connection: ::core::option::Option<KafkaConnectionOptions>,
    /// Authentication settings
    #[prost(message, optional, tag = "2")]
    pub auth: ::core::option::Option<KafkaAuth>,
    /// Security groups
    #[prost(string, repeated, tag = "3")]
    pub security_groups: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Full source topic name
    /// Deprecated in favor of topic names
    #[deprecated]
    #[prost(string, tag = "4")]
    pub topic_name: ::prost::alloc::string::String,
    /// Data transformation rules
    #[prost(message, optional, tag = "5")]
    pub transformer: ::core::option::Option<DataTransformationOptions>,
    /// Data parsing rules
    #[prost(message, optional, tag = "7")]
    pub parser: ::core::option::Option<Parser>,
    /// List of topic names to read
    #[prost(string, repeated, tag = "8")]
    pub topic_names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct KafkaTarget {
    /// Connection settings
    #[prost(message, optional, tag = "1")]
    pub connection: ::core::option::Option<KafkaConnectionOptions>,
    /// Authentication settings
    #[prost(message, optional, tag = "2")]
    pub auth: ::core::option::Option<KafkaAuth>,
    /// Security groups
    #[prost(string, repeated, tag = "3")]
    pub security_groups: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Target topic settings
    #[prost(message, optional, tag = "7")]
    pub topic_settings: ::core::option::Option<KafkaTargetTopicSettings>,
    /// Data serialization format settings
    #[prost(message, optional, tag = "8")]
    pub serializer: ::core::option::Option<Serializer>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct KafkaTargetTopicSettings {
    #[prost(oneof = "kafka_target_topic_settings::TopicSettings", tags = "1, 2")]
    pub topic_settings: ::core::option::Option<
        kafka_target_topic_settings::TopicSettings,
    >,
}
/// Nested message and enum types in `KafkaTargetTopicSettings`.
pub mod kafka_target_topic_settings {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum TopicSettings {
        /// Full topic name
        #[prost(message, tag = "1")]
        Topic(super::KafkaTargetTopic),
        /// Topic prefix
        ///
        /// Analogue of the Debezium setting database.server.name.
        /// Messages will be sent to topic with name <topic_prefix>.<schema>.<table_name>.
        #[prost(string, tag = "2")]
        TopicPrefix(::prost::alloc::string::String),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct KafkaTargetTopic {
    /// Topic name
    #[prost(string, tag = "1")]
    pub topic_name: ::prost::alloc::string::String,
    /// Save transactions order
    /// Not to split events queue into separate per-table queues.
    #[prost(bool, tag = "2")]
    pub save_tx_order: bool,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum KafkaMechanism {
    Unspecified = 0,
    Sha256 = 1,
    Sha512 = 2,
}
impl KafkaMechanism {
    /// 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 {
            KafkaMechanism::Unspecified => "KAFKA_MECHANISM_UNSPECIFIED",
            KafkaMechanism::Sha256 => "KAFKA_MECHANISM_SHA256",
            KafkaMechanism::Sha512 => "KAFKA_MECHANISM_SHA512",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "KAFKA_MECHANISM_UNSPECIFIED" => Some(Self::Unspecified),
            "KAFKA_MECHANISM_SHA256" => Some(Self::Sha256),
            "KAFKA_MECHANISM_SHA512" => Some(Self::Sha512),
            _ => None,
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MetrikaStream {
    #[prost(enumeration = "MetrikaStreamType", tag = "1")]
    pub r#type: i32,
    #[prost(string, repeated, tag = "2")]
    pub columns: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MetrikaSource {
    #[prost(int64, repeated, tag = "1")]
    pub counter_ids: ::prost::alloc::vec::Vec<i64>,
    #[prost(message, optional, tag = "2")]
    pub token: ::core::option::Option<Secret>,
    #[prost(message, repeated, tag = "3")]
    pub streams: ::prost::alloc::vec::Vec<MetrikaStream>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum MetrikaStreamType {
    Unspecified = 0,
    Hits = 1,
    Visits = 2,
    HitsV2 = 3,
}
impl MetrikaStreamType {
    /// 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 {
            MetrikaStreamType::Unspecified => "METRIKA_STREAM_TYPE_UNSPECIFIED",
            MetrikaStreamType::Hits => "METRIKA_STREAM_TYPE_HITS",
            MetrikaStreamType::Visits => "METRIKA_STREAM_TYPE_VISITS",
            MetrikaStreamType::HitsV2 => "METRIKA_STREAM_TYPE_HITS_V2",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "METRIKA_STREAM_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
            "METRIKA_STREAM_TYPE_HITS" => Some(Self::Hits),
            "METRIKA_STREAM_TYPE_VISITS" => Some(Self::Visits),
            "METRIKA_STREAM_TYPE_HITS_V2" => Some(Self::HitsV2),
            _ => None,
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OnPremiseMongo {
    #[prost(string, repeated, tag = "1")]
    pub hosts: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(int64, tag = "2")]
    pub port: i64,
    #[prost(string, tag = "5")]
    pub replica_set: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "6")]
    pub tls_mode: ::core::option::Option<TlsMode>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MongoConnectionOptions {
    /// User name
    #[prost(string, tag = "3")]
    pub user: ::prost::alloc::string::String,
    /// Password for user
    #[prost(message, optional, tag = "4")]
    pub password: ::core::option::Option<Secret>,
    /// Database name associated with the credentials
    #[prost(string, tag = "5")]
    pub auth_source: ::prost::alloc::string::String,
    #[prost(oneof = "mongo_connection_options::Address", tags = "1, 2")]
    pub address: ::core::option::Option<mongo_connection_options::Address>,
}
/// Nested message and enum types in `MongoConnectionOptions`.
pub mod mongo_connection_options {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Address {
        #[prost(string, tag = "1")]
        MdbClusterId(::prost::alloc::string::String),
        #[prost(message, tag = "2")]
        OnPremise(super::OnPremiseMongo),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MongoConnection {
    #[prost(oneof = "mongo_connection::Connection", tags = "3")]
    pub connection: ::core::option::Option<mongo_connection::Connection>,
}
/// Nested message and enum types in `MongoConnection`.
pub mod mongo_connection {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Connection {
        #[prost(message, tag = "3")]
        ConnectionOptions(super::MongoConnectionOptions),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MongoCollection {
    #[prost(string, tag = "1")]
    pub database_name: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub collection_name: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MongoSource {
    #[prost(message, optional, tag = "1")]
    pub connection: ::core::option::Option<MongoConnection>,
    #[prost(string, tag = "2")]
    pub subnet_id: ::prost::alloc::string::String,
    /// List of collections for replication. Empty list implies replication of all
    /// tables on the deployment. Allowed to use * as collection name.
    #[prost(message, repeated, tag = "6")]
    pub collections: ::prost::alloc::vec::Vec<MongoCollection>,
    /// List of forbidden collections for replication. Allowed to use * as collection
    /// name for forbid all collections of concrete schema.
    #[prost(message, repeated, tag = "7")]
    pub excluded_collections: ::prost::alloc::vec::Vec<MongoCollection>,
    /// Read mode for mongo client
    #[prost(bool, tag = "8")]
    pub secondary_preferred_mode: bool,
    /// Security groups
    #[prost(string, repeated, tag = "11")]
    pub security_groups: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MongoTarget {
    #[prost(message, optional, tag = "1")]
    pub connection: ::core::option::Option<MongoConnection>,
    /// Database name
    #[prost(string, tag = "2")]
    pub database: ::prost::alloc::string::String,
    #[prost(enumeration = "CleanupPolicy", tag = "6")]
    pub cleanup_policy: i32,
    #[prost(string, tag = "7")]
    pub subnet_id: ::prost::alloc::string::String,
    /// Security groups
    #[prost(string, repeated, tag = "8")]
    pub security_groups: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OnPremiseMysql {
    /// Database port
    #[prost(int64, tag = "2")]
    pub port: i64,
    /// Network interface for endpoint. If none will assume public ipv4
    #[prost(string, tag = "4")]
    pub subnet_id: ::prost::alloc::string::String,
    #[prost(string, repeated, tag = "5")]
    pub hosts: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// TLS settings for server connection. Disabled by default.
    #[prost(message, optional, tag = "6")]
    pub tls_mode: ::core::option::Option<TlsMode>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MysqlConnection {
    #[prost(oneof = "mysql_connection::Connection", tags = "1, 2, 3")]
    pub connection: ::core::option::Option<mysql_connection::Connection>,
}
/// Nested message and enum types in `MysqlConnection`.
pub mod mysql_connection {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Connection {
        /// Managed Service for MySQL cluster ID
        #[prost(string, tag = "1")]
        MdbClusterId(::prost::alloc::string::String),
        /// Connection options for on-premise MySQL
        #[prost(message, tag = "2")]
        OnPremise(super::OnPremiseMysql),
        #[prost(message, tag = "3")]
        ConnectionManagerConnection(super::ConnectionManagerConnection),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MysqlObjectTransferSettings {
    /// Views
    ///
    /// CREATE VIEW ...
    #[prost(enumeration = "ObjectTransferStage", tag = "1")]
    pub view: i32,
    /// Routines
    ///
    /// CREATE PROCEDURE ... ; CREATE FUNCTION ... ;
    #[prost(enumeration = "ObjectTransferStage", tag = "2")]
    pub routine: i32,
    /// Triggers
    ///
    /// CREATE TRIGGER ...
    #[prost(enumeration = "ObjectTransferStage", tag = "3")]
    pub trigger: i32,
    #[prost(enumeration = "ObjectTransferStage", tag = "4")]
    pub tables: i32,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MysqlSource {
    /// Database connection settings
    #[prost(message, optional, tag = "1")]
    pub connection: ::core::option::Option<MysqlConnection>,
    /// Database name
    ///
    /// You can leave it empty, then it will be possible to transfer tables from several
    /// databases at the same time from this source.
    #[prost(string, tag = "2")]
    pub database: ::prost::alloc::string::String,
    /// User for database access. not required as may be in connection
    #[prost(string, tag = "3")]
    pub user: ::prost::alloc::string::String,
    /// Password for database access.
    #[prost(message, optional, tag = "4")]
    pub password: ::core::option::Option<Secret>,
    /// Database timezone
    ///
    /// Is used for parsing timestamps for saving source timezones. Accepts values from
    /// IANA timezone database. Default: local timezone.
    #[prost(string, tag = "8")]
    pub timezone: ::prost::alloc::string::String,
    /// Schema migration
    ///
    /// Select database objects to be transferred during activation or deactivation.
    #[prost(message, optional, tag = "11")]
    pub object_transfer_settings: ::core::option::Option<MysqlObjectTransferSettings>,
    #[prost(string, repeated, tag = "12")]
    pub include_tables_regex: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(string, repeated, tag = "13")]
    pub exclude_tables_regex: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Security groups
    #[prost(string, repeated, tag = "14")]
    pub security_groups: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Database for service tables
    ///
    /// Default: data source database. Here created technical tables (__tm_keeper,
    /// __tm_gtid_keeper).
    #[prost(string, tag = "15")]
    pub service_database: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MysqlTarget {
    /// Database connection settings
    #[prost(message, optional, tag = "1")]
    pub connection: ::core::option::Option<MysqlConnection>,
    /// Database name
    ///
    /// Allowed to leave it empty, then the tables will be created in databases with the
    /// same names as on the source. If this field is empty, then you must fill below db
    /// schema for service table.
    #[prost(string, tag = "2")]
    pub database: ::prost::alloc::string::String,
    /// User for database access. not required as may be in connection
    #[prost(string, tag = "3")]
    pub user: ::prost::alloc::string::String,
    /// Password for database access.
    #[prost(message, optional, tag = "4")]
    pub password: ::core::option::Option<Secret>,
    /// Default: NO_AUTO_VALUE_ON_ZERO,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION.
    #[prost(string, tag = "5")]
    pub sql_mode: ::prost::alloc::string::String,
    /// Disable constraints checks
    ///
    /// Recommend to disable for increase replication speed, but if schema contain
    /// cascading operations we don't recommend to disable. This option set
    /// FOREIGN_KEY_CHECKS=0 and UNIQUE_CHECKS=0.
    #[prost(bool, tag = "6")]
    pub skip_constraint_checks: bool,
    /// Database timezone
    ///
    /// Is used for parsing timestamps for saving source timezones. Accepts values from
    /// IANA timezone database. Default: local timezone.
    #[prost(string, tag = "7")]
    pub timezone: ::prost::alloc::string::String,
    /// Cleanup policy
    ///
    /// Cleanup policy for activate, reactivate and reupload processes. Default is
    /// DISABLED.
    #[prost(enumeration = "CleanupPolicy", tag = "8")]
    pub cleanup_policy: i32,
    /// Database schema for service table
    ///
    /// Default: db name. Here created technical tables (__tm_keeper, __tm_gtid_keeper).
    #[prost(string, tag = "15")]
    pub service_database: ::prost::alloc::string::String,
    /// Security groups
    #[prost(string, repeated, tag = "16")]
    pub security_groups: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PostgresObjectTransferSettings {
    /// Sequences
    ///
    /// CREATE SEQUENCE ...
    #[prost(enumeration = "ObjectTransferStage", tag = "1")]
    pub sequence: i32,
    /// Owned sequences
    ///
    /// CREATE SEQUENCE ... OWNED BY ...
    #[prost(enumeration = "ObjectTransferStage", tag = "2")]
    pub sequence_owned_by: i32,
    /// Tables
    ///
    /// CREATE TABLE ...
    #[prost(enumeration = "ObjectTransferStage", tag = "3")]
    pub table: i32,
    /// Primary keys
    ///
    /// ALTER TABLE ... ADD PRIMARY KEY ...
    #[prost(enumeration = "ObjectTransferStage", tag = "4")]
    pub primary_key: i32,
    /// Foreign keys
    ///
    /// ALTER TABLE ... ADD FOREIGN KEY ...
    #[prost(enumeration = "ObjectTransferStage", tag = "5")]
    pub fk_constraint: i32,
    /// Default values
    ///
    /// ALTER TABLE ... ALTER COLUMN ... SET DEFAULT ...
    #[prost(enumeration = "ObjectTransferStage", tag = "6")]
    pub default_values: i32,
    /// Constraints
    ///
    /// ALTER TABLE ... ADD CONSTRAINT ...
    #[prost(enumeration = "ObjectTransferStage", tag = "7")]
    pub constraint: i32,
    /// Indexes
    ///
    /// CREATE INDEX ...
    #[prost(enumeration = "ObjectTransferStage", tag = "8")]
    pub index: i32,
    /// Views
    ///
    /// CREATE VIEW ...
    #[prost(enumeration = "ObjectTransferStage", tag = "9")]
    pub view: i32,
    /// Functions
    ///
    /// CREATE FUNCTION ...
    #[prost(enumeration = "ObjectTransferStage", tag = "10")]
    pub function: i32,
    /// Triggers
    ///
    /// CREATE TRIGGER ...
    #[prost(enumeration = "ObjectTransferStage", tag = "11")]
    pub trigger: i32,
    /// Types
    ///
    /// CREATE TYPE ...
    #[prost(enumeration = "ObjectTransferStage", tag = "12")]
    pub r#type: i32,
    /// Rules
    ///
    /// CREATE RULE ...
    #[prost(enumeration = "ObjectTransferStage", tag = "13")]
    pub rule: i32,
    /// Collations
    ///
    /// CREATE COLLATION ...
    #[prost(enumeration = "ObjectTransferStage", tag = "14")]
    pub collation: i32,
    /// Policies
    ///
    /// CREATE POLICY ...
    #[prost(enumeration = "ObjectTransferStage", tag = "15")]
    pub policy: i32,
    /// Casts
    ///
    /// CREATE CAST ...
    #[prost(enumeration = "ObjectTransferStage", tag = "16")]
    pub cast: i32,
    /// Materialized views
    ///
    /// CREATE MATERIALIZED VIEW ...
    #[prost(enumeration = "ObjectTransferStage", tag = "17")]
    pub materialized_view: i32,
    /// Sequence sets
    ///
    /// CREATE SEQUENCE ...
    #[prost(enumeration = "ObjectTransferStage", tag = "18")]
    pub sequence_set: i32,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OnPremisePostgres {
    /// Will be used if the cluster ID is not specified.
    #[prost(int64, tag = "2")]
    pub port: i64,
    /// Network interface for endpoint. If none will assume public ipv4
    #[prost(string, tag = "4")]
    pub subnet_id: ::prost::alloc::string::String,
    #[prost(string, repeated, tag = "5")]
    pub hosts: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// TLS settings for server connection. Disabled by default.
    #[prost(message, optional, tag = "6")]
    pub tls_mode: ::core::option::Option<TlsMode>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PostgresConnection {
    #[prost(oneof = "postgres_connection::Connection", tags = "1, 2, 3")]
    pub connection: ::core::option::Option<postgres_connection::Connection>,
}
/// Nested message and enum types in `PostgresConnection`.
pub mod postgres_connection {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Connection {
        /// Managed Service for PostgreSQL cluster ID
        #[prost(string, tag = "1")]
        MdbClusterId(::prost::alloc::string::String),
        /// Connection options for on-premise PostgreSQL
        #[prost(message, tag = "2")]
        OnPremise(super::OnPremisePostgres),
        #[prost(message, tag = "3")]
        ConnectionManagerConnection(super::ConnectionManagerConnection),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PostgresSource {
    /// Database connection settings
    #[prost(message, optional, tag = "1")]
    pub connection: ::core::option::Option<PostgresConnection>,
    /// Database name
    #[prost(string, tag = "2")]
    pub database: ::prost::alloc::string::String,
    /// User for database access. not required as may be in connection
    #[prost(string, tag = "3")]
    pub user: ::prost::alloc::string::String,
    /// Password for database access.
    #[prost(message, optional, tag = "4")]
    pub password: ::core::option::Option<Secret>,
    /// Included tables
    ///
    /// If none or empty list is presented, all tables are replicated. Full table name
    /// with schema. Can contain schema_name.* patterns.
    #[prost(string, repeated, tag = "5")]
    pub include_tables: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Excluded tables
    ///
    /// If none or empty list is presented, all tables are replicated. Full table name
    /// with schema. Can contain schema_name.* patterns.
    #[prost(string, repeated, tag = "6")]
    pub exclude_tables: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Maximum lag of replication slot (in bytes); after exceeding this limit
    /// replication will be aborted.
    #[prost(int64, tag = "8")]
    pub slot_byte_lag_limit: i64,
    /// Database schema for service tables (__consumer_keeper,
    /// __data_transfer_mole_finder). Default is public
    #[prost(string, tag = "9")]
    pub service_schema: ::prost::alloc::string::String,
    /// Select database objects to be transferred during activation or deactivation.
    #[prost(message, optional, tag = "13")]
    pub object_transfer_settings: ::core::option::Option<PostgresObjectTransferSettings>,
    /// Security groups
    #[prost(string, repeated, tag = "14")]
    pub security_groups: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PostgresTarget {
    /// Database connection settings
    #[prost(message, optional, tag = "1")]
    pub connection: ::core::option::Option<PostgresConnection>,
    /// Database name
    #[prost(string, tag = "2")]
    pub database: ::prost::alloc::string::String,
    /// User for database access. not required as may be in connection
    #[prost(string, tag = "3")]
    pub user: ::prost::alloc::string::String,
    /// Password for database access.
    #[prost(message, optional, tag = "4")]
    pub password: ::core::option::Option<Secret>,
    /// Cleanup policy for activate, reactivate and reupload processes. Default is
    /// truncate.
    #[prost(enumeration = "CleanupPolicy", tag = "5")]
    pub cleanup_policy: i32,
    /// Security groups
    #[prost(string, repeated, tag = "7")]
    pub security_groups: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct YdbSource {
    /// Path in YDB where to store tables
    #[prost(string, tag = "1")]
    pub database: ::prost::alloc::string::String,
    /// Instance of YDB. example: ydb-ru-prestable.yandex.net:2135
    #[prost(string, tag = "2")]
    pub instance: ::prost::alloc::string::String,
    #[prost(string, repeated, tag = "5")]
    pub paths: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(string, tag = "6")]
    pub service_account_id: ::prost::alloc::string::String,
    /// Network interface for endpoint. If none will assume public ipv4
    #[prost(string, tag = "30")]
    pub subnet_id: ::prost::alloc::string::String,
    /// Authorization Key
    #[prost(string, tag = "33")]
    pub sa_key_content: ::prost::alloc::string::String,
    /// Security groups
    #[prost(string, repeated, tag = "34")]
    pub security_groups: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Pre-created change feed
    #[prost(string, tag = "35")]
    pub changefeed_custom_name: ::prost::alloc::string::String,
    #[prost(string, tag = "36")]
    pub changefeed_custom_consumer_name: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct YdbTarget {
    /// Path in YDB where to store tables
    #[prost(string, tag = "1")]
    pub database: ::prost::alloc::string::String,
    /// Instance of YDB. example: ydb-ru-prestable.yandex.net:2135
    #[prost(string, tag = "2")]
    pub instance: ::prost::alloc::string::String,
    /// Path extension for database, each table will be layouted into this path
    #[prost(string, tag = "10")]
    pub path: ::prost::alloc::string::String,
    #[prost(string, tag = "11")]
    pub service_account_id: ::prost::alloc::string::String,
    /// Cleanup policy
    #[prost(enumeration = "YdbCleanupPolicy", tag = "21")]
    pub cleanup_policy: i32,
    /// Network interface for endpoint. If none will assume public ipv4
    #[prost(string, tag = "30")]
    pub subnet_id: ::prost::alloc::string::String,
    /// SA content
    #[prost(string, tag = "32")]
    pub sa_key_content: ::prost::alloc::string::String,
    /// Security groups
    #[prost(string, repeated, tag = "33")]
    pub security_groups: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Should create column-oriented table (OLAP). By default it creates row-oriented
    /// (OLTP)
    #[prost(bool, tag = "34")]
    pub is_table_column_oriented: bool,
    /// Compression that will be used for default columns family on YDB table creation
    #[prost(enumeration = "YdbDefaultCompression", tag = "35")]
    pub default_compression: i32,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum YdbCleanupPolicy {
    Unspecified = 0,
    Disabled = 1,
    Drop = 2,
}
impl YdbCleanupPolicy {
    /// 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 {
            YdbCleanupPolicy::Unspecified => "YDB_CLEANUP_POLICY_UNSPECIFIED",
            YdbCleanupPolicy::Disabled => "YDB_CLEANUP_POLICY_DISABLED",
            YdbCleanupPolicy::Drop => "YDB_CLEANUP_POLICY_DROP",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "YDB_CLEANUP_POLICY_UNSPECIFIED" => Some(Self::Unspecified),
            "YDB_CLEANUP_POLICY_DISABLED" => Some(Self::Disabled),
            "YDB_CLEANUP_POLICY_DROP" => Some(Self::Drop),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum YdbDefaultCompression {
    Unspecified = 0,
    Disabled = 1,
    Lz4 = 2,
}
impl YdbDefaultCompression {
    /// 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 {
            YdbDefaultCompression::Unspecified => "YDB_DEFAULT_COMPRESSION_UNSPECIFIED",
            YdbDefaultCompression::Disabled => "YDB_DEFAULT_COMPRESSION_DISABLED",
            YdbDefaultCompression::Lz4 => "YDB_DEFAULT_COMPRESSION_LZ4",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "YDB_DEFAULT_COMPRESSION_UNSPECIFIED" => Some(Self::Unspecified),
            "YDB_DEFAULT_COMPRESSION_DISABLED" => Some(Self::Disabled),
            "YDB_DEFAULT_COMPRESSION_LZ4" => Some(Self::Lz4),
            _ => None,
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct YdsSource {
    /// Database
    #[prost(string, tag = "1")]
    pub database: ::prost::alloc::string::String,
    /// Stream
    #[prost(string, tag = "2")]
    pub stream: ::prost::alloc::string::String,
    /// SA which has read access to the stream.
    #[prost(string, tag = "8")]
    pub service_account_id: ::prost::alloc::string::String,
    /// Compression codec
    #[prost(enumeration = "YdsCompressionCodec", repeated, tag = "9")]
    pub supported_codecs: ::prost::alloc::vec::Vec<i32>,
    /// Data parsing rules
    #[prost(message, optional, tag = "10")]
    pub parser: ::core::option::Option<Parser>,
    /// Should continue working, if consumer read lag exceed TTL of topic
    /// False: stop the transfer in error state, if detected lost data. True: continue
    /// working with losing part of data
    #[prost(bool, tag = "11")]
    pub allow_ttl_rewind: bool,
    /// for dedicated db
    #[prost(string, tag = "20")]
    pub endpoint: ::prost::alloc::string::String,
    /// Network interface for endpoint. If none will assume public ipv4
    #[prost(string, tag = "30")]
    pub subnet_id: ::prost::alloc::string::String,
    /// Security groups
    #[prost(string, repeated, tag = "34")]
    pub security_groups: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// for important streams
    #[prost(string, tag = "35")]
    pub consumer: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct YdsTarget {
    /// Database
    #[prost(string, tag = "1")]
    pub database: ::prost::alloc::string::String,
    /// Stream
    #[prost(string, tag = "2")]
    pub stream: ::prost::alloc::string::String,
    /// SA which has read access to the stream.
    #[prost(string, tag = "3")]
    pub service_account_id: ::prost::alloc::string::String,
    /// Save transaction order
    /// Not to split events queue into separate per-table queues.
    /// Incompatible with setting Topic prefix, only with Topic full name.
    #[prost(bool, tag = "4")]
    pub save_tx_order: bool,
    #[prost(enumeration = "YdsCompressionCodec", tag = "5")]
    pub compression_codec: i32,
    /// Data serialization format
    #[prost(message, optional, tag = "8")]
    pub serializer: ::core::option::Option<Serializer>,
    /// for dedicated db
    #[prost(string, tag = "20")]
    pub endpoint: ::prost::alloc::string::String,
    /// Network interface for endpoint. If none will assume public ipv4
    #[prost(string, tag = "30")]
    pub subnet_id: ::prost::alloc::string::String,
    /// Security groups
    #[prost(string, repeated, tag = "34")]
    pub security_groups: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum YdsCompressionCodec {
    Unspecified = 0,
    Raw = 1,
    Gzip = 2,
    Zstd = 4,
}
impl YdsCompressionCodec {
    /// 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 {
            YdsCompressionCodec::Unspecified => "YDS_COMPRESSION_CODEC_UNSPECIFIED",
            YdsCompressionCodec::Raw => "YDS_COMPRESSION_CODEC_RAW",
            YdsCompressionCodec::Gzip => "YDS_COMPRESSION_CODEC_GZIP",
            YdsCompressionCodec::Zstd => "YDS_COMPRESSION_CODEC_ZSTD",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "YDS_COMPRESSION_CODEC_UNSPECIFIED" => Some(Self::Unspecified),
            "YDS_COMPRESSION_CODEC_RAW" => Some(Self::Raw),
            "YDS_COMPRESSION_CODEC_GZIP" => Some(Self::Gzip),
            "YDS_COMPRESSION_CODEC_ZSTD" => Some(Self::Zstd),
            _ => None,
        }
    }
}