content: /*
   * Licensed to the Apache Software Foundation (ASF) under one or more
   * contributor license agreements.  See the NOTICE file distributed with
   * this work for additional information regarding copyright ownership.
   * The ASF licenses this file to You under the Apache License, Version 2.0
   * (the "License"); you may not use this file except in compliance with
   * the License.  You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.apache.camel.component.debezium.postgres.springboot;
  
  import java.util.Map;
  import org.apache.camel.component.debezium.postgres.configuration.PostgresConnectorEmbeddedDebeziumConfiguration;
  import org.apache.camel.spring.boot.ComponentConfigurationPropertiesCommon;
  import org.springframework.boot.context.properties.ConfigurationProperties;
  
  /**
   * Capture changes from a PostgresSQL database.
   * 
   * Generated by camel-package-maven-plugin - do not edit this file!
   */
  @ConfigurationProperties(prefix = "camel.component.debezium-postgres")
  public class DebeziumPostgresComponentConfiguration
          extends
              ComponentConfigurationPropertiesCommon {
  
      /**
       * Whether to enable auto configuration of the debezium-postgres component.
       * This is enabled by default.
       */
      private Boolean enabled;
      /**
       * Additional properties for debezium components in case they can't be set
       * directly on the camel configurations (e.g: setting Kafka Connect
       * properties needed by Debezium engine, for example setting
       * KafkaOffsetBackingStore), the properties have to be prefixed with
       * additionalProperties.. E.g:
       * additionalProperties.transactional.id=12345&additionalProperties.schema.registry.url=http://localhost:8811/avro. This is a multi-value option with prefix: additionalProperties.
       */
      private Map<String, Object> additionalProperties;
      /**
       * Allows for bridging the consumer to the Camel routing Error Handler,
       * which mean any exceptions (if possible) occurred while the Camel consumer
       * is trying to pickup incoming messages, or the likes, will now be
       * processed as a message and handled by the routing Error Handler.
       * Important: This is only possible if the 3rd party component allows Camel
       * to be alerted if an exception was thrown. Some components handle this
       * internally only, and therefore bridgeErrorHandler is not possible. In
       * other situations we may improve the Camel component to hook into the 3rd
       * party component and make this possible for future releases. By default
       * the consumer will use the org.apache.camel.spi.ExceptionHandler to deal
       * with exceptions, that will be logged at WARN or ERROR level and ignored.
       */
      private Boolean bridgeErrorHandler = false;
      /**
       * Allow pre-configured Configurations to be set. The option is a
       * org.apache.camel.component.debezium.postgres.configuration.PostgresConnectorEmbeddedDebeziumConfiguration type.
       */
      private PostgresConnectorEmbeddedDebeziumConfiguration configuration;
      /**
       * The Converter class that should be used to serialize and deserialize key
       * data for offsets. The default is JSON converter.
       */
      private String internalKeyConverter = "org.apache.kafka.connect.json.JsonConverter";
      /**
       * The Converter class that should be used to serialize and deserialize
       * value data for offsets. The default is JSON converter.
       */
      private String internalValueConverter = "org.apache.kafka.connect.json.JsonConverter";
      /**
       * The name of the Java class of the commit policy. It defines when offsets
       * commit has to be triggered based on the number of events processed and
       * the time elapsed since the last commit. This class must implement the
       * interface 'OffsetCommitPolicy'. The default is a periodic commit policy
       * based upon time intervals.
       */
      private String offsetCommitPolicy;
      /**
       * Maximum number of milliseconds to wait for records to flush and partition
       * offset data to be committed to offset storage before cancelling the
       * process and restoring the offset data to be committed in a future
       * attempt. The default is 5 seconds. The option is a long type.
       */
      private Long offsetCommitTimeoutMs = 5000L;
      /**
       * Interval at which to try committing offsets. The default is 1 minute. The
       * option is a long type.
       */
      private Long offsetFlushIntervalMs = 60000L;
      /**
       * The name of the Java class that is responsible for persistence of
       * connector offsets.
       */
      private String offsetStorage = "org.apache.kafka.connect.storage.FileOffsetBackingStore";
      /**
       * Path to file where offsets are to be stored. Required when offset.storage
       * is set to the FileOffsetBackingStore.
       */
      private String offsetStorageFileName;
      /**
       * The number of partitions used when creating the offset storage topic.
       * Required when offset.storage is set to the 'KafkaOffsetBackingStore'.
       */
      private Integer offsetStoragePartitions;
      /**
       * Replication factor used when creating the offset storage topic. Required
       * when offset.storage is set to the KafkaOffsetBackingStore
       */
      private Integer offsetStorageReplicationFactor;
      /**
       * The name of the Kafka topic where offsets are to be stored. Required when
       * offset.storage is set to the KafkaOffsetBackingStore.
       */
      private String offsetStorageTopic;
      /**
       * Whether autowiring is enabled. This is used for automatic autowiring
       * options (the option must be marked as autowired) by looking up in the
       * registry to find if there is a single instance of matching type, which
       * then gets configured on the component. This can be used for automatic
       * configuring JDBC data sources, JMS connection factories, AWS Clients,
       * etc.
       */
      private Boolean autowiredEnabled = true;
      /**
       * Specify how binary (blob, binary, etc.) columns should be represented in
       * change events, including: 'bytes' represents binary data as byte array
       * (default); 'base64' represents binary data as base64-encoded string;
       * 'base64-url-safe' represents binary data as base64-url-safe-encoded
       * string; 'hex' represents binary data as hex-encoded (base16) string
       */
      private String binaryHandlingMode = "bytes";
      /**
       * Regular expressions matching columns to exclude from change events
       */
      private String columnExcludeList;
      /**
       * Regular expressions matching columns to include in change events
       */
      private String columnIncludeList;
      /**
       * A comma-separated list of regular expressions matching fully-qualified
       * names of columns that adds the columns original type and original length
       * as parameters to the corresponding field schemas in the emitted change
       * records.
       */
      private String columnPropagateSourceType;
      /**
       * The maximum time in milliseconds to wait for connection validation to
       * complete. Defaults to 60 seconds. The option is a long type.
       */
      private Long connectionValidationTimeoutMs = 60000L;
      /**
       * Optional list of custom converters that would be used instead of default
       * ones. The converters are defined using '.type' config option and
       * configured using options '.'
       */
      private String converters;
      /**
       * The custom metric tags will accept key-value pairs to customize the MBean
       * object name which should be appended the end of regular name, each key
       * would represent a tag for the MBean object name, and the corresponding
       * value would be the value of that tag the key is. For example: k1=v1,k2=v2
       */
      private String customMetricTags;
      /**
       * The name of the database from which the connector should capture changes
       */
      private String databaseDbname;
      /**
       * Resolvable hostname or IP address of the database server.
       */
      private String databaseHostname;
      /**
       * A semicolon separated list of SQL statements to be executed when a JDBC
       * connection to the database is established. Note that the connector may
       * establish JDBC connections at its own discretion, so this should
       * typically be used for configuration of session parameters only, but not
       * for executing DML statements. Use doubled semicolon (';;') to use a
       * semicolon as a character and not as a delimiter.
       */
      private String databaseInitialStatements;
      /**
       * Password of the database user to be used when connecting to the database.
       */
      private String databasePassword;
      /**
       * Port of the database server.
       */
      private Integer databasePort = 5432;
      /**
       * Time to wait for a query to execute, given in milliseconds. Defaults to
       * 600 seconds (600,000 ms); zero means there is no limit. The option is a
       * int type.
       */
      private Integer databaseQueryTimeoutMs = 600000;
      /**
       * File containing the SSL Certificate for the client. See the Postgres SSL
       * docs for further information
       */
      private String databaseSslcert;
      /**
       * A name of class to that creates SSL Sockets. Use
       * org.postgresql.ssl.NonValidatingFactory to disable SSL validation in
       * development environments
       */
      private String databaseSslfactory;
      /**
       * File containing the SSL private key for the client. See the Postgres SSL
       * docs for further information
       */
      private String databaseSslkey;
      /**
       * Whether to use an encrypted connection to Postgres. Options include:
       * 'disable' (the default) to use an unencrypted connection; 'allow' to try
       * and use an unencrypted connection first and, failing that, a secure
       * (encrypted) connection; 'prefer' (the default) to try and use a secure
       * (encrypted) connection first and, failing that, an unencrypted
       * connection; 'require' to use a secure (encrypted) connection, and fail if
       * one cannot be established; 'verify-ca' like 'required' but additionally
       * verify the server TLS certificate against the configured Certificate
       * Authority (CA) certificates, or fail if no valid matching CA certificates
       * are found; or 'verify-full' like 'verify-ca' but additionally verify that
       * the server certificate matches the host to which the connection is
       * attempted.
       */
      private String databaseSslmode = "prefer";
      /**
       * Password to access the client private key from the file specified by
       * 'database.sslkey'. See the Postgres SSL docs for further information
       */
      private String databaseSslpassword;
      /**
       * File containing the root certificate(s) against which the server is
       * validated. See the Postgres JDBC SSL docs for further information
       */
      private String databaseSslrootcert;
      /**
       * Enable or disable TCP keep-alive probe to avoid dropping TCP connection
       */
      private Boolean databaseTcpkeepalive = true;
      /**
       * Name of the database user to be used when connecting to the database.
       */
      private String databaseUser;
      /**
       * A comma-separated list of regular expressions matching the
       * database-specific data type names that adds the data type's original type
       * and original length as parameters to the corresponding field schemas in
       * the emitted change records.
       */
      private String datatypePropagateSourceType;
      /**
       * Specify how DECIMAL and NUMERIC columns should be represented in change
       * events, including: 'precise' (the default) uses java.math.BigDecimal to
       * represent values, which are encoded in the change events using a binary
       * representation and Kafka Connect's
       * 'org.apache.kafka.connect.data.Decimal' type; 'string' uses string to
       * represent values; 'double' represents values using Java's 'double', which
       * may not offer the precision but will be far easier to use in consumers.
       */
      private String decimalHandlingMode = "precise";
      /**
       * The maximum number of retries on connection errors before failing (-1 =
       * no limit, 0 = disabled, 0 = num of retries).
       */
      private Integer errorsMaxRetries = -1;
      /**
       * Specify how failures during processing of events (i.e. when encountering
       * a corrupted event) should be handled, including: 'fail' (the default) an
       * exception indicating the problematic event and its position is raised,
       * causing the connector to be stopped; 'warn' the problematic event and its
       * position will be logged and the event will be skipped; 'ignore' the
       * problematic event will be skipped.
       */
      private String eventProcessingFailureHandlingMode = "fail";
      /**
       * The maximum time in milliseconds to wait for task executor to shut down.
       * The option is a long type.
       */
      private Long executorShutdownTimeoutMs = 4000L;
      /**
       * Enable/Disable Debezium context headers that provides essential metadata
       * for tracking and identifying the source of CDC events in downstream
       * processing systems.
       */
      private Boolean extendedHeadersEnabled = true;
      /**
       * Boolean to determine if Debezium should flush LSN in the source postgres
       * database. If set to false, user will have to flush the LSN manually
       * outside Debezium.
       */
      private Boolean flushLsnSource = true;
      /**
       * Specify the action to take when a guardrail collections limit is
       * exceeded: 'warn' (the default) logs a warning message and continues
       * processing; 'fail' stops the connector with an error.
       */
      private String guardrailCollectionsLimitAction = "warn";
      /**
       * The maximum number of collections or tables that can be captured by the
       * connector. When this limit is exceeded, the action specified by
       * 'guardrail.collections.limit.action' will be taken. Set to 0 to disable
       * this guardrail.
       */
      private Integer guardrailCollectionsMax = 0;
      /**
       * The query executed with every heartbeat.
       */
      private String heartbeatActionQuery;
      /**
       * Length of an interval in milli-seconds in in which the connector
       * periodically sends heartbeat messages to a heartbeat topic. Use 0 to
       * disable heartbeat messages. Disabled by default. The option is a int
       * type.
       */
      private Integer heartbeatIntervalMs = 0;
      /**
       * The prefix that is used to name heartbeat topics.Defaults to
       * __debezium-heartbeat.
       */
      private String heartbeatTopicsPrefix = "__debezium-heartbeat";
      /**
       * Specify how HSTORE columns should be represented in change events,
       * including: 'json' represents values as string-ified JSON (default); 'map'
       * represents values as a key/value map
       */
      private String hstoreHandlingMode = "json";
      /**
       * Whether the connector parse table and column's comment to metadata
       * object. Note: Enable this option will bring the implications on memory
       * usage. The number and size of ColumnImpl objects is what largely impacts
       * how much memory is consumed by the Debezium connectors, and adding a
       * String to each of them can potentially be quite heavy. The default is
       * 'false'.
       */
      private Boolean includeSchemaComments = false;
      /**
       * Specify whether the fields of data type not supported by Debezium should
       * be processed: 'false' (the default) omits the fields; 'true' converts the
       * field into an implementation dependent binary representation.
       */
      private Boolean includeUnknownDatatypes = false;
      /**
       * The maximum size of chunk (number of documents/rows) for incremental
       * snapshotting
       */
      private Integer incrementalSnapshotChunkSize = 1024;
      /**
       * Specify the strategy used for watermarking during an incremental
       * snapshot: 'insert_insert' both open and close signal is written into
       * signal data collection (default); 'insert_delete' only open signal is
       * written on signal data collection, the close will delete the relative
       * open signal;
       */
      private String incrementalSnapshotWatermarkingStrategy = "INSERT_INSERT";
      /**
       * Specify how INTERVAL columns should be represented in change events,
       * including: 'string' represents values as an exact ISO formatted string;
       * 'numeric' (default) represents values using the inexact conversion into
       * microseconds
       */
      private String intervalHandlingMode = "numeric";
      /**
       * Action to take when an LSN flush timeout occurs. Options include: 'fail'
       * (default) to fail the connector; 'warn' to log a warning and continue
       * processing; 'ignore' to continue processing and ignore the timeout.
       */
      private String lsnFlushTimeoutAction = "fail";
      /**
       * Maximum time in milliseconds to wait for LSN flush operation to complete.
       * If the flush operation does not complete within this timeout, the action
       * specified by lsn.flush.timeout.action will be taken. Defaults to 30
       * seconds. The option is a long type.
       */
      private Long lsnFlushTimeoutMs = 30000L;
      /**
       * Maximum size of each batch of source records. Defaults to 2048.
       */
      private Integer maxBatchSize = 2048;
      /**
       * Maximum size of the queue for change events read from the database log
       * but not yet recorded or forwarded. Defaults to 8192, and should always be
       * larger than the maximum batch size.
       */
      private Integer maxQueueSize = 8192;
      /**
       * Maximum size of the queue in bytes for change events read from the
       * database log but not yet recorded or forwarded. Defaults to 0. Mean the
       * feature is not enabled
       */
      private Long maxQueueSizeInBytes = 0L;
      /**
       * A semicolon-separated list of expressions that match fully-qualified
       * tables and column(s) to be used as message key. Each expression must
       * match the pattern ':', where the table names could be defined as
       * (DB_NAME.TABLE_NAME) or (SCHEMA_NAME.TABLE_NAME), depending on the
       * specific connector, and the key columns are a comma-separated list of
       * columns representing the custom key. For any table without an explicit
       * key configuration the table's primary key column(s) will be used as
       * message key. Example:
       * dbserver1.inventory.orderlines:orderId,orderLineId;dbserver1.inventory.orders:id
       */
      private String messageKeyColumns;
      /**
       * A comma-separated list of regular expressions that match the logical
       * decoding message prefixes to be excluded from monitoring.
       */
      private String messagePrefixExcludeList;
      /**
       * A comma-separated list of regular expressions that match the logical
       * decoding message prefixes to be monitored. All prefixes are monitored by
       * default.
       */
      private String messagePrefixIncludeList;
      /**
       * List of notification channels names that are enabled.
       */
      private String notificationEnabledChannels;
      /**
       * The name of the topic for the notifications. This is required in case
       * 'sink' is in the list of enabled channels
       */
      private String notificationSinkTopicName;
      /**
       * Path to OpenLineage file configuration. See
       * https://openlineage.io/docs/client/java/configuration
       */
      private String openlineageIntegrationConfigFilePath = "./openlineage.yml";
      /**
       * The Kafka bootstrap server address used as input/output namespace/
       */
      private String openlineageIntegrationDatasetKafkaBootstrapServers;
      /**
       * Enable Debezium to emit data lineage metadata through OpenLineage API
       */
      private Boolean openlineageIntegrationEnabled = false;
      /**
       * The job's description emitted by Debezium
       */
      private String openlineageIntegrationJobDescription = "Debezium change data capture job";
      /**
       * The job's namespace emitted by Debezium
       */
      private String openlineageIntegrationJobNamespace;
      /**
       * The job's owners emitted by Debezium. A comma-separated list of key-value
       * pairs.For example: k1=v1,k2=v2
       */
      private String openlineageIntegrationJobOwners;
      /**
       * The job's tags emitted by Debezium. A comma-separated list of key-value
       * pairs.For example: k1=v1,k2=v2
       */
      private String openlineageIntegrationJobTags;
      /**
       * The name of the Postgres logical decoding plugin installed on the server.
       * Supported values are 'decoderbufs' and 'pgoutput'. Defaults to
       * 'decoderbufs'.
       */
      private String pluginName = "decoderbufs";
      /**
       * Time to wait for new change events to appear after receiving no events,
       * given in milliseconds. Defaults to 500 ms. The option is a long type.
       */
      private Long pollIntervalMs = 500L;
      /**
       * Optional list of post processors. The processors are defined using
       * '.type' config option and configured using options ''
       */
      private String postProcessors;
      /**
       * Enables transaction metadata extraction together with event counting
       */
      private Boolean provideTransactionMetadata = false;
      /**
       * Applies only when streaming changes using pgoutput.Determine how creation
       * of a publication should work, the default is all_tables.DISABLED - The
       * connector will not attempt to create a publication at all. The
       * expectation is that the user has created the publication up-front. If the
       * publication isn't found to exist upon startup, the connector will throw
       * an exception and stop.ALL_TABLES - If no publication exists, the
       * connector will create a new publication for all tables. Note this
       * requires that the configured user has access. If the publication already
       * exists, it will be used. i.e CREATE PUBLICATION FOR ALL TABLES;FILTERED -
       * If no publication exists, the connector will create a new publication for
       * all those tables matchingthe current filter configuration (see
       * table/database include/exclude list properties). If the publication
       * already exists, it will be used. i.e CREATE PUBLICATION FOR TABLE
       */
      private String publicationAutocreateMode = "all_tables";
      /**
       * The name of the Postgres 10 publication used for streaming changes from a
       * plugin. Defaults to 'dbz_publication'
       */
      private String publicationName = "dbz_publication";
      /**
       * A boolean that determines whether the connector should publish changes
       * via the partition root. When true, changes are published through
       * partition root. When false, changes are published directly.
       */
      private Boolean publishViaPartitionRoot = false;
      /**
       * The maximum number of records that should be loaded into memory while
       * streaming. A value of '0' uses the default JDBC fetch size.
       */
      private Integer queryFetchSize = 0;
      /**
       * Applies only when streaming changes using pgoutput.Determines the value
       * for Replica Identity at table level. This option will overwrite the
       * existing value in databaseA comma-separated list of regular expressions
       * that match fully-qualified tables and Replica Identity value to be used
       * in the table. Each expression must match the pattern ':', where the table
       * names could be defined as (SCHEMA_NAME.TABLE_NAME), and the replica
       * identity values are: DEFAULT - Records the old values of the columns of
       * the primary key, if any. This is the default for non-system tables.INDEX
       * index_name - Records the old values of the columns covered by the named
       * index, that must be unique, not partial, not deferrable, and include only
       * columns marked NOT NULL. If this index is dropped, the behavior is the
       * same as NOTHING.FULL - Records the old values of all columns in the
       * row.NOTHING - Records no information about the old row. This is the
       * default for system tables.
       */
      private String replicaIdentityAutosetValues;
      /**
       * Time to wait before restarting connector after retriable exception
       * occurs. Defaults to 10000ms. The option is a long type.
       */
      private Long retriableRestartConnectorWaitMs = 10000L;
      /**
       * The schemas for which events must not be captured
       */
      private String schemaExcludeList;
      /**
       * The path to the file that will be used to record the database schema
       * history
       */
      private String schemaHistoryInternalFileFilename;
      /**
       * The schemas for which events should be captured
       */
      private String schemaIncludeList;
      /**
       * Specify how schema names should be adjusted for compatibility with the
       * message converter used by the connector, including: 'avro' replaces the
       * characters that cannot be used in the Avro type name with underscore;
       * 'avro_unicode' replaces the underscore or characters that cannot be used
       * in the Avro type name with corresponding unicode like _uxxxx. Note: _ is
       * an escape sequence like backslash in Java;'none' does not apply any
       * adjustment (default)
       */
      private String schemaNameAdjustmentMode = "none";
      /**
       * Specify the conditions that trigger a refresh of the in-memory schema for
       * a table. 'columns_diff' (the default) is the safest mode, ensuring the
       * in-memory schema stays in-sync with the database table's schema at all
       * times. 'columns_diff_exclude_unchanged_toast' instructs the connector to
       * refresh the in-memory schema cache if there is a discrepancy between it
       * and the schema derived from the incoming message, unless unchanged
       * TOASTable data fully accounts for the discrepancy. This setting can
       * improve connector performance significantly if there are
       * frequently-updated tables that have TOASTed data that are rarely part of
       * these updates. However, it is possible for the in-memory schema to become
       * outdated if TOASTable columns are dropped from the table.
       */
      private String schemaRefreshMode = "columns_diff";
      /**
       * The name of the data collection that is used to send signals/commands to
       * Debezium. Signaling is disabled when not set.
       */
      private String signalDataCollection;
      /**
       * List of channels names that are enabled. Source channel is enabled by
       * default
       */
      private String signalEnabledChannels = "source";
      /**
       * Interval for looking for new signals in registered channels, given in
       * milliseconds. Defaults to 5 seconds. The option is a long type.
       */
      private Long signalPollIntervalMs = 5000L;
      /**
       * The comma-separated list of operations to skip during streaming, defined
       * as: 'c' for inserts/create; 'u' for updates; 'd' for deletes, 't' for
       * truncates, and 'none' to indicate nothing skipped. By default, only
       * truncate operations will be skipped.
       */
      private String skippedOperations = "t";
      /**
       * Whether or not to drop the logical replication slot when the connector
       * finishes orderly. By default the replication is kept so that on restart
       * progress can resume from the last recorded location
       */
      private Boolean slotDropOnStop = false;
      /**
       * Whether or not to create a failover slot. This is only supported when
       * connecting to a primary server of a Postgres cluster, version 17 or
       * newer. When not specified, or when not connecting to a Postgres 17
       * primary, no failover slot will be created.
       */
      private Boolean slotFailover = false;
      /**
       * How many times to retry connecting to a replication slot when an attempt
       * fails.
       */
      private Integer slotMaxRetries = 6;
      /**
       * The name of the Postgres logical decoding slot created for streaming
       * changes from a plugin. Defaults to 'debezium
       */
      private String slotName = "debezium";
      /**
       * Time to wait between retry attempts when the connector fails to connect
       * to a replication slot, given in milliseconds. Defaults to 10 seconds
       * (10,000 ms). The option is a long type.
       */
      private Long slotRetryDelayMs = 10000L;
      /**
       * Any optional parameters used by logical decoding plugin. Semi-colon
       * separated. E.g. 'add-tables=public.table,public.table2;include-lsn=true'
       */
      private String slotStreamParams;
      /**
       * A delay period before a snapshot will begin, given in milliseconds.
       * Defaults to 0 ms. The option is a long type.
       */
      private Long snapshotDelayMs = 0L;
      /**
       * The maximum number of records that should be loaded into memory while
       * performing a snapshot.
       */
      private Integer snapshotFetchSize;
      /**
       * This setting must be set to specify a list of tables/collections whose
       * snapshot must be taken on creating or restarting the connector.
       */
      private String snapshotIncludeCollectionList;
      /**
       * Controls which transaction isolation level is used. The default is
       * 'serializable', which means that serializable isolation level is used.
       * When 'repeatable_read' is specified, connector runs the initial snapshot
       * in REPEATABLE READ isolation level. When 'read_committed' is specified,
       * connector runs the initial snapshot in READ COMMITTED isolation level. In
       * 'read_uncommitted' is specified, connector runs the initial snapshot in
       * READ UNCOMMITTED isolation level.
       */
      private String snapshotIsolationMode = "serializable";
      /**
       * Controls how the connector holds locks on tables while performing the
       * schema snapshot. The 'shared' which means the connector will hold a table
       * lock that prevents exclusive table access for just the initial portion of
       * the snapshot while the database schemas and other metadata are being
       * read. The remaining work in a snapshot involves selecting all rows from
       * each table, and this is done using a flashback query that requires no
       * locks. However, in some cases it may be desirable to avoid locks entirely
       * which can be done by specifying 'none'. This mode is only safe to use if
       * no schema changes are happening while the snapshot is taken.
       */
      private String snapshotLockingMode = "none";
      /**
       * When 'snapshot.locking.mode' is set as custom, this setting must be set
       * to specify a the name of the custom implementation provided in the
       * 'name()' method. The implementations must implement the
       * 'SnapshotterLocking' interface and is called to determine how to lock
       * tables during schema snapshot.
       */
      private String snapshotLockingModeCustomName;
      /**
       * The maximum number of millis to wait for table locks at the beginning of
       * a snapshot. If locks cannot be acquired in this time frame, the snapshot
       * will be aborted. Defaults to 10 seconds. The option is a long type.
       */
      private Long snapshotLockTimeoutMs = 10000L;
      /**
       * The maximum number of threads used to perform the snapshot. Defaults to
       * 1.
       */
      private Integer snapshotMaxThreads = 1;
      /**
       * The criteria for running a snapshot upon startup of the connector. Select
       * one of the following snapshot options: 'always': The connector runs a
       * snapshot every time that it starts. After the snapshot completes, the
       * connector begins to stream changes from the transaction log.; 'initial'
       * (default): If the connector does not detect any offsets for the logical
       * server name, it runs a snapshot that captures the current full state of
       * the configured tables. After the snapshot completes, the connector begins
       * to stream changes from the transaction log. 'initial_only': The connector
       * performs a snapshot as it does for the 'initial' option, but after the
       * connector completes the snapshot, it stops, and does not stream changes
       * from the transaction log.; 'never': The connector does not run a
       * snapshot. Upon first startup, the connector immediately begins reading
       * from the beginning of the transaction log. 'exported': This option is
       * deprecated; use 'initial' instead.; 'custom': The connector loads a
       * custom class to specify how the connector performs snapshots. For more
       * information, see Custom snapshotter SPI in the PostgreSQL connector
       * documentation.
       */
      private String snapshotMode = "initial";
      /**
       * When 'snapshot.mode' is set as configuration_based, this setting permits
       * to specify whenever the data should be snapshotted or not.
       */
      private Boolean snapshotModeConfigurationBasedSnapshotData = false;
      /**
       * When 'snapshot.mode' is set as configuration_based, this setting permits
       * to specify whenever the data should be snapshotted or not in case of
       * error.
       */
      private Boolean snapshotModeConfigurationBasedSnapshotOnDataError = false;
      /**
       * When 'snapshot.mode' is set as configuration_based, this setting permits
       * to specify whenever the schema should be snapshotted or not in case of
       * error.
       */
      private Boolean snapshotModeConfigurationBasedSnapshotOnSchemaError = false;
      /**
       * When 'snapshot.mode' is set as configuration_based, this setting permits
       * to specify whenever the schema should be snapshotted or not.
       */
      private Boolean snapshotModeConfigurationBasedSnapshotSchema = false;
      /**
       * When 'snapshot.mode' is set as configuration_based, this setting permits
       * to specify whenever the stream should start or not after snapshot.
       */
      private Boolean snapshotModeConfigurationBasedStartStream = false;
      /**
       * When 'snapshot.mode' is set as custom, this setting must be set to
       * specify a the name of the custom implementation provided in the 'name()'
       * method. The implementations must implement the 'Snapshotter' interface
       * and is called on each app boot to determine whether to do a snapshot.
       */
      private String snapshotModeCustomName;
      /**
       * Controls query used during the snapshot
       */
      private String snapshotQueryMode = "select_all";
      /**
       * When 'snapshot.query.mode' is set as custom, this setting must be set to
       * specify a the name of the custom implementation provided in the 'name()'
       * method. The implementations must implement the 'SnapshotterQuery'
       * interface and is called to determine how to build queries during
       * snapshot.
       */
      private String snapshotQueryModeCustomName;
      /**
       * This property contains a comma-separated list of fully-qualified tables
       * (DB_NAME.TABLE_NAME) or (SCHEMA_NAME.TABLE_NAME), depending on the
       * specific connectors. Select statements for the individual tables are
       * specified in further configuration properties, one for each table,
       * identified by the id
       * 'snapshot.select.statement.overrides.DB_NAME.TABLE_NAME' or
       * 'snapshot.select.statement.overrides.SCHEMA_NAME.TABLE_NAME',
       * respectively. The value of those properties is the select statement to
       * use when retrieving data from the specific table during snapshotting. A
       * possible use case for large append-only tables is setting a specific
       * point where to start (resume) snapshotting, in case a previous
       * snapshotting was interrupted.
       */
      private String snapshotSelectStatementOverrides;
      /**
       * Controls the order in which tables are processed in the initial snapshot.
       * A descending value will order the tables by row count descending. A
       * ascending value will order the tables by row count ascending. A value of
       * disabled (the default) will disable ordering by row count.
       */
      private String snapshotTablesOrderByRowCount = "disabled";
      /**
       * The name of the SourceInfoStructMaker class that returns SourceInfo
       * schema and struct.
       */
      private String sourceinfoStructMaker = "io.debezium.connector.postgresql.PostgresSourceInfoStructMaker";
      /**
       * Frequency for sending replication connection status updates to the
       * server, given in milliseconds. Defaults to 10 seconds (10,000 ms). The
       * option is a int type.
       */
      private Integer statusUpdateIntervalMs = 10000;
      /**
       * A delay period after the snapshot is completed and the streaming begins,
       * given in milliseconds. Defaults to 0 ms. The option is a long type.
       */
      private Long streamingDelayMs = 0L;
      /**
       * A comma-separated list of regular expressions that match the
       * fully-qualified names of tables to be excluded from monitoring
       */
      private String tableExcludeList;
      /**
       * Flag specifying whether built-in tables should be ignored.
       */
      private Boolean tableIgnoreBuiltin = true;
      /**
       * The tables for which changes are to be captured
       */
      private String tableIncludeList;
      /**
       * Time, date, and timestamps can be represented with different kinds of
       * precisions, including: 'adaptive' (the default) bases the precision of
       * time, date, and timestamp values on the database column's precision;
       * 'adaptive_time_microseconds' like 'adaptive' mode, but TIME fields always
       * use microseconds precision; 'connect' always represents time, date, and
       * timestamp values using Kafka Connect's built-in representations for Time,
       * Date, and Timestamp, which uses millisecond precision regardless of the
       * database columns' precision.
       */
      private String timePrecisionMode = "adaptive";
      /**
       * Whether delete operations should be represented by a delete event and a
       * subsequent tombstone event (true) or only by a delete event (false).
       * Emitting the tombstone event (the default behavior) allows Kafka to
       * completely delete all events pertaining to the given key once the source
       * record got deleted.
       */
      private Boolean tombstonesOnDelete = false;
      /**
       * The name of the TopicNamingStrategy class that should be used to
       * determine the topic name for data change, schema change, transaction,
       * heartbeat event etc.
       */
      private String topicNamingStrategy = "io.debezium.schema.SchemaTopicNamingStrategy";
      /**
       * Topic prefix that identifies and provides a namespace for the particular
       * database server/cluster is capturing changes. The topic prefix should be
       * unique across all other connectors, since it is used as a prefix for all
       * Kafka topic names that receive events emitted by this connector. Only
       * alphanumeric characters, hyphens, dots and underscores must be accepted.
       */
      private String topicPrefix;
      /**
       * Class to make transaction context & transaction struct/schemas
       */
      private String transactionMetadataFactory = "io.debezium.pipeline.txmetadata.DefaultTransactionMetadataFactory";
      /**
       * Specify the constant that will be provided by Debezium to indicate that
       * the original value is a toasted value not provided by the database. If
       * starts with 'hex:' prefix it is expected that the rest of the string
       * represents hexadecimal encoded octets.
       */
      private String unavailableValuePlaceholder = "__debezium_unavailable_value";
      /**
       * Specify how often (in ms) the xmin will be fetched from the replication
       * slot. This xmin value is exposed by the slot which gives a lower bound of
       * where a new replication slot could start from. The lower the value, the
       * more likely this value is to be the current 'true' value, but the bigger
       * the performance cost. The bigger the value, the less likely this value is
       * to be the current 'true' value, but the lower the performance penalty.
       * The default is set to 0 ms, which disables tracking xmin. The option is a
       * long type.
       */
      private Long xminFetchIntervalMs = 0L;
  
      public Map<String, Object> getAdditionalProperties() {
          return additionalProperties;
      }
  
      public void setAdditionalProperties(Map<String, Object> additionalProperties) {
          this.additionalProperties = additionalProperties;
      }
  
      public Boolean getBridgeErrorHandler() {
          return bridgeErrorHandler;
      }
  
      public void setBridgeErrorHandler(Boolean bridgeErrorHandler) {
          this.bridgeErrorHandler = bridgeErrorHandler;
      }
  
      public PostgresConnectorEmbeddedDebeziumConfiguration getConfiguration() {
          return configuration;
      }
  
      public void setConfiguration(
              PostgresConnectorEmbeddedDebeziumConfiguration configuration) {
          this.configuration = configuration;
      }
  
      public String getInternalKeyConverter() {
          return internalKeyConverter;
      }
  
      public void setInternalKeyConverter(String internalKeyConverter) {
          this.internalKeyConverter = internalKeyConverter;
      }
  
      public String getInternalValueConverter() {
          return internalValueConverter;
      }
  
      public void setInternalValueConverter(String internalValueConverter) {
          this.internalValueConverter = internalValueConverter;
      }
  
      public String getOffsetCommitPolicy() {
          return offsetCommitPolicy;
      }
  
      public void setOffsetCommitPolicy(String offsetCommitPolicy) {
          this.offsetCommitPolicy = offsetCommitPolicy;
      }
  
      public Long getOffsetCommitTimeoutMs() {
          return offsetCommitTimeoutMs;
      }
  
      public void setOffsetCommitTimeoutMs(Long offsetCommitTimeoutMs) {
          this.offsetCommitTimeoutMs = offsetCommitTimeoutMs;
      }
  
      public Long getOffsetFlushIntervalMs() {
          return offsetFlushIntervalMs;
      }
  
      public void setOffsetFlushIntervalMs(Long offsetFlushIntervalMs) {
          this.offsetFlushIntervalMs = offsetFlushIntervalMs;
      }
  
      public String getOffsetStorage() {
          return offsetStorage;
      }
  
      public void setOffsetStorage(String offsetStorage) {
          this.offsetStorage = offsetStorage;
      }
  
      public String getOffsetStorageFileName() {
          return offsetStorageFileName;
      }
  
      public void setOffsetStorageFileName(String offsetStorageFileName) {
          this.offsetStorageFileName = offsetStorageFileName;
      }
  
      public Integer getOffsetStoragePartitions() {
          return offsetStoragePartitions;
      }
  
      public void setOffsetStoragePartitions(Integer offsetStoragePartitions) {
          this.offsetStoragePartitions = offsetStoragePartitions;
      }
  
      public Integer getOffsetStorageReplicationFactor() {
          return offsetStorageReplicationFactor;
      }
  
      public void setOffsetStorageReplicationFactor(
              Integer offsetStorageReplicationFactor) {
          this.offsetStorageReplicationFactor = offsetStorageReplicationFactor;
      }
  
      public String getOffsetStorageTopic() {
          return offsetStorageTopic;
      }
  
      public void setOffsetStorageTopic(String offsetStorageTopic) {
          this.offsetStorageTopic = offsetStorageTopic;
      }
  
      public Boolean getAutowiredEnabled() {
          return autowiredEnabled;
      }
  
      public void setAutowiredEnabled(Boolean autowiredEnabled) {
          this.autowiredEnabled = autowiredEnabled;
      }
  
      public String getBinaryHandlingMode() {
          return binaryHandlingMode;
      }
  
      public void setBinaryHandlingMode(String binaryHandlingMode) {
          this.binaryHandlingMode = binaryHandlingMode;
      }
  
      public String getColumnExcludeList() {
          return columnExcludeList;
      }
  
      public void setColumnExcludeList(String columnExcludeList) {
          this.columnExcludeList = columnExcludeList;
      }
  
      public String getColumnIncludeList() {
          return columnIncludeList;
      }
  
      public void setColumnIncludeList(String columnIncludeList) {
          this.columnIncludeList = columnIncludeList;
      }
  
      public String getColumnPropagateSourceType() {
          return columnPropagateSourceType;
      }
  
      public void setColumnPropagateSourceType(String columnPropagateSourceType) {
          this.columnPropagateSourceType = columnPropagateSourceType;
      }
  
      public Long getConnectionValidationTimeoutMs() {
          return connectionValidationTimeoutMs;
      }
  
      public void setConnectionValidationTimeoutMs(
              Long connectionValidationTimeoutMs) {
          this.connectionValidationTimeoutMs = connectionValidationTimeoutMs;
      }
  
      public String getConverters() {
          return converters;
      }
  
      public void setConverters(String converters) {
          this.converters = converters;
      }
  
      public String getCustomMetricTags() {
          return customMetricTags;
      }
  
      public void setCustomMetricTags(String customMetricTags) {
          this.customMetricTags = customMetricTags;
      }
  
      public String getDatabaseDbname() {
          return databaseDbname;
      }
  
      public void setDatabaseDbname(String databaseDbname) {
          this.databaseDbname = databaseDbname;
      }
  
      public String getDatabaseHostname() {
          return databaseHostname;
      }
  
      public void setDatabaseHostname(String databaseHostname) {
          this.databaseHostname = databaseHostname;
      }
  
      public String getDatabaseInitialStatements() {
          return databaseInitialStatements;
      }
  
      public void setDatabaseInitialStatements(String databaseInitialStatements) {
          this.databaseInitialStatements = databaseInitialStatements;
      }
  
      public String getDatabasePassword() {
          return databasePassword;
      }
  
      public void setDatabasePassword(String databasePassword) {
          this.databasePassword = databasePassword;
      }
  
      public Integer getDatabasePort() {
          return databasePort;
      }
  
      public void setDatabasePort(Integer databasePort) {
          this.databasePort = databasePort;
      }
  
      public Integer getDatabaseQueryTimeoutMs() {
          return databaseQueryTimeoutMs;
      }
  
      public void setDatabaseQueryTimeoutMs(Integer databaseQueryTimeoutMs) {
          this.databaseQueryTimeoutMs = databaseQueryTimeoutMs;
      }
  
      public String getDatabaseSslcert() {
          return databaseSslcert;
      }
  
      public void setDatabaseSslcert(String databaseSslcert) {
          this.databaseSslcert = databaseSslcert;
      }
  
      public String getDatabaseSslfactory() {
          return databaseSslfactory;
      }
  
      public void setDatabaseSslfactory(String databaseSslfactory) {
          this.databaseSslfactory = databaseSslfactory;
      }
  
      public String getDatabaseSslkey() {
          return databaseSslkey;
      }
  
      public void setDatabaseSslkey(String databaseSslkey) {
          this.databaseSslkey = databaseSslkey;
      }
  
      public String getDatabaseSslmode() {
          return databaseSslmode;
      }
  
      public void setDatabaseSslmode(String databaseSslmode) {
          this.databaseSslmode = databaseSslmode;
      }
  
      public String getDatabaseSslpassword() {
          return databaseSslpassword;
      }
  
      public void setDatabaseSslpassword(String databaseSslpassword) {
          this.databaseSslpassword = databaseSslpassword;
      }
  
      public String getDatabaseSslrootcert() {
          return databaseSslrootcert;
      }
  
      public void setDatabaseSslrootcert(String databaseSslrootcert) {
          this.databaseSslrootcert = databaseSslrootcert;
      }
  
      public Boolean getDatabaseTcpkeepalive() {
          return databaseTcpkeepalive;
      }
  
      public void setDatabaseTcpkeepalive(Boolean databaseTcpkeepalive) {
          this.databaseTcpkeepalive = databaseTcpkeepalive;
      }
  
      public String getDatabaseUser() {
          return databaseUser;
      }
  
      public void setDatabaseUser(String databaseUser) {
          this.databaseUser = databaseUser;
      }
  
      public String getDatatypePropagateSourceType() {
          return datatypePropagateSourceType;
      }
  
      public void setDatatypePropagateSourceType(
              String datatypePropagateSourceType) {
          this.datatypePropagateSourceType = datatypePropagateSourceType;
      }
  
      public String getDecimalHandlingMode() {
          return decimalHandlingMode;
      }
  
      public void setDecimalHandlingMode(String decimalHandlingMode) {
          this.decimalHandlingMode = decimalHandlingMode;
      }
  
      public Integer getErrorsMaxRetries() {
          return errorsMaxRetries;
      }
  
      public void setErrorsMaxRetries(Integer errorsMaxRetries) {
          this.errorsMaxRetries = errorsMaxRetries;
      }
  
      public String getEventProcessingFailureHandlingMode() {
          return eventProcessingFailureHandlingMode;
      }
  
      public void setEventProcessingFailureHandlingMode(
              String eventProcessingFailureHandlingMode) {
          this.eventProcessingFailureHandlingMode = eventProcessingFailureHandlingMode;
      }
  
      public Long getExecutorShutdownTimeoutMs() {
          return executorShutdownTimeoutMs;
      }
  
      public void setExecutorShutdownTimeoutMs(Long executorShutdownTimeoutMs) {
          this.executorShutdownTimeoutMs = executorShutdownTimeoutMs;
      }
  
      public Boolean getExtendedHeadersEnabled() {
          return extendedHeadersEnabled;
      }
  
      public void setExtendedHeadersEnabled(Boolean extendedHeadersEnabled) {
          this.extendedHeadersEnabled = extendedHeadersEnabled;
      }
  
      public Boolean getFlushLsnSource() {
          return flushLsnSource;
      }
  
      public void setFlushLsnSource(Boolean flushLsnSource) {
          this.flushLsnSource = flushLsnSource;
      }
  
      public String getGuardrailCollectionsLimitAction() {
          return guardrailCollectionsLimitAction;
      }
  
      public void setGuardrailCollectionsLimitAction(
              String guardrailCollectionsLimitAction) {
          this.guardrailCollectionsLimitAction = guardrailCollectionsLimitAction;
      }
  
      public Integer getGuardrailCollectionsMax() {
          return guardrailCollectionsMax;
      }
  
      public void setGuardrailCollectionsMax(Integer guardrailCollectionsMax) {
          this.guardrailCollectionsMax = guardrailCollectionsMax;
      }
  
      public String getHeartbeatActionQuery() {
          return heartbeatActionQuery;
      }
  
      public void setHeartbeatActionQuery(String heartbeatActionQuery) {
          this.heartbeatActionQuery = heartbeatActionQuery;
      }
  
      public Integer getHeartbeatIntervalMs() {
          return heartbeatIntervalMs;
      }
  
      public void setHeartbeatIntervalMs(Integer heartbeatIntervalMs) {
          this.heartbeatIntervalMs = heartbeatIntervalMs;
      }
  
      public String getHeartbeatTopicsPrefix() {
          return heartbeatTopicsPrefix;
      }
  
      public void setHeartbeatTopicsPrefix(String heartbeatTopicsPrefix) {
          this.heartbeatTopicsPrefix = heartbeatTopicsPrefix;
      }
  
      public String getHstoreHandlingMode() {
          return hstoreHandlingMode;
      }
  
      public void setHstoreHandlingMode(String hstoreHandlingMode) {
          this.hstoreHandlingMode = hstoreHandlingMode;
      }
  
      public Boolean getIncludeSchemaComments() {
          return includeSchemaComments;
      }
  
      public void setIncludeSchemaComments(Boolean includeSchemaComments) {
          this.includeSchemaComments = includeSchemaComments;
      }
  
      public Boolean getIncludeUnknownDatatypes() {
          return includeUnknownDatatypes;
      }
  
      public void setIncludeUnknownDatatypes(Boolean includeUnknownDatatypes) {
          this.includeUnknownDatatypes = includeUnknownDatatypes;
      }
  
      public Integer getIncrementalSnapshotChunkSize() {
          return incrementalSnapshotChunkSize;
      }
  
      public void setIncrementalSnapshotChunkSize(
              Integer incrementalSnapshotChunkSize) {
          this.incrementalSnapshotChunkSize = incrementalSnapshotChunkSize;
      }
  
      public String getIncrementalSnapshotWatermarkingStrategy() {
          return incrementalSnapshotWatermarkingStrategy;
      }
  
      public void setIncrementalSnapshotWatermarkingStrategy(
              String incrementalSnapshotWatermarkingStrategy) {
          this.incrementalSnapshotWatermarkingStrategy = incrementalSnapshotWatermarkingStrategy;
      }
  
      public String getIntervalHandlingMode() {
          return intervalHandlingMode;
      }
  
      public void setIntervalHandlingMode(String intervalHandlingMode) {
          this.intervalHandlingMode = intervalHandlingMode;
      }
  
      public String getLsnFlushTimeoutAction() {
          return lsnFlushTimeoutAction;
      }
  
      public void setLsnFlushTimeoutAction(String lsnFlushTimeoutAction) {
          this.lsnFlushTimeoutAction = lsnFlushTimeoutAction;
      }
  
      public Long getLsnFlushTimeoutMs() {
          return lsnFlushTimeoutMs;
      }
  
      public void setLsnFlushTimeoutMs(Long lsnFlushTimeoutMs) {
          this.lsnFlushTimeoutMs = lsnFlushTimeoutMs;
      }
  
      public Integer getMaxBatchSize() {
          return maxBatchSize;
      }
  
      public void setMaxBatchSize(Integer maxBatchSize) {
          this.maxBatchSize = maxBatchSize;
      }
  
      public Integer getMaxQueueSize() {
          return maxQueueSize;
      }
  
      public void setMaxQueueSize(Integer maxQueueSize) {
          this.maxQueueSize = maxQueueSize;
      }
  
      public Long getMaxQueueSizeInBytes() {
          return maxQueueSizeInBytes;
      }
  
      public void setMaxQueueSizeInBytes(Long maxQueueSizeInBytes) {
          this.maxQueueSizeInBytes = maxQueueSizeInBytes;
      }
  
      public String getMessageKeyColumns() {
          return messageKeyColumns;
      }
  
      public void setMessageKeyColumns(String messageKeyColumns) {
          this.messageKeyColumns = messageKeyColumns;
      }
  
      public String getMessagePrefixExcludeList() {
          return messagePrefixExcludeList;
      }
  
      public void setMessagePrefixExcludeList(String messagePrefixExcludeList) {
          this.messagePrefixExcludeList = messagePrefixExcludeList;
      }
  
      public String getMessagePrefixIncludeList() {
          return messagePrefixIncludeList;
      }
  
      public void setMessagePrefixIncludeList(String messagePrefixIncludeList) {
          this.messagePrefixIncludeList = messagePrefixIncludeList;
      }
  
      public String getNotificationEnabledChannels() {
          return notificationEnabledChannels;
      }
  
      public void setNotificationEnabledChannels(
              String notificationEnabledChannels) {
          this.notificationEnabledChannels = notificationEnabledChannels;
      }
  
      public String getNotificationSinkTopicName() {
          return notificationSinkTopicName;
      }
  
      public void setNotificationSinkTopicName(String notificationSinkTopicName) {
          this.notificationSinkTopicName = notificationSinkTopicName;
      }
  
      public String getOpenlineageIntegrationConfigFilePath() {
          return openlineageIntegrationConfigFilePath;
      }
  
      public void setOpenlineageIntegrationConfigFilePath(
              String openlineageIntegrationConfigFilePath) {
          this.openlineageIntegrationConfigFilePath = openlineageIntegrationConfigFilePath;
      }
  
      public String getOpenlineageIntegrationDatasetKafkaBootstrapServers() {
          return openlineageIntegrationDatasetKafkaBootstrapServers;
      }
  
      public void setOpenlineageIntegrationDatasetKafkaBootstrapServers(
              String openlineageIntegrationDatasetKafkaBootstrapServers) {
          this.openlineageIntegrationDatasetKafkaBootstrapServers = openlineageIntegrationDatasetKafkaBootstrapServers;
      }
  
      public Boolean getOpenlineageIntegrationEnabled() {
          return openlineageIntegrationEnabled;
      }
  
      public void setOpenlineageIntegrationEnabled(
              Boolean openlineageIntegrationEnabled) {
          this.openlineageIntegrationEnabled = openlineageIntegrationEnabled;
      }
  
      public String getOpenlineageIntegrationJobDescription() {
          return openlineageIntegrationJobDescription;
      }
  
      public void setOpenlineageIntegrationJobDescription(
              String openlineageIntegrationJobDescription) {
          this.openlineageIntegrationJobDescription = openlineageIntegrationJobDescription;
      }
  
      public String getOpenlineageIntegrationJobNamespace() {
          return openlineageIntegrationJobNamespace;
      }
  
      public void setOpenlineageIntegrationJobNamespace(
              String openlineageIntegrationJobNamespace) {
          this.openlineageIntegrationJobNamespace = openlineageIntegrationJobNamespace;
      }
  
      public String getOpenlineageIntegrationJobOwners() {
          return openlineageIntegrationJobOwners;
      }
  
      public void setOpenlineageIntegrationJobOwners(
              String openlineageIntegrationJobOwners) {
          this.openlineageIntegrationJobOwners = openlineageIntegrationJobOwners;
      }
  
      public String getOpenlineageIntegrationJobTags() {
          return openlineageIntegrationJobTags;
      }
  
      public void setOpenlineageIntegrationJobTags(
              String openlineageIntegrationJobTags) {
          this.openlineageIntegrationJobTags = openlineageIntegrationJobTags;
      }
  
      public String getPluginName() {
          return pluginName;
      }
  
      public void setPluginName(String pluginName) {
          this.pluginName = pluginName;
      }
  
      public Long getPollIntervalMs() {
          return pollIntervalMs;
      }
  
      public void setPollIntervalMs(Long pollIntervalMs) {
          this.pollIntervalMs = pollIntervalMs;
      }
  
      public String getPostProcessors() {
          return postProcessors;
      }
  
      public void setPostProcessors(String postProcessors) {
          this.postProcessors = postProcessors;
      }
  
      public Boolean getProvideTransactionMetadata() {
          return provideTransactionMetadata;
      }
  
      public void setProvideTransactionMetadata(Boolean provideTransactionMetadata) {
          this.provideTransactionMetadata = provideTransactionMetadata;
      }
  
      public String getPublicationAutocreateMode() {
          return publicationAutocreateMode;
      }
  
      public void setPublicationAutocreateMode(String publicationAutocreateMode) {
          this.publicationAutocreateMode = publicationAutocreateMode;
      }
  
      public String getPublicationName() {
          return publicationName;
      }
  
      public void setPublicationName(String publicationName) {
          this.publicationName = publicationName;
      }
  
      public Boolean getPublishViaPartitionRoot() {
          return publishViaPartitionRoot;
      }
  
      public void setPublishViaPartitionRoot(Boolean publishViaPartitionRoot) {
          this.publishViaPartitionRoot = publishViaPartitionRoot;
      }
  
      public Integer getQueryFetchSize() {
          return queryFetchSize;
      }
  
      public void setQueryFetchSize(Integer queryFetchSize) {
          this.queryFetchSize = queryFetchSize;
      }
  
      public String getReplicaIdentityAutosetValues() {
          return replicaIdentityAutosetValues;
      }
  
      public void setReplicaIdentityAutosetValues(
              String replicaIdentityAutosetValues) {
          this.replicaIdentityAutosetValues = replicaIdentityAutosetValues;
      }
  
      public Long getRetriableRestartConnectorWaitMs() {
          return retriableRestartConnectorWaitMs;
      }
  
      public void setRetriableRestartConnectorWaitMs(
              Long retriableRestartConnectorWaitMs) {
          this.retriableRestartConnectorWaitMs = retriableRestartConnectorWaitMs;
      }
  
      public String getSchemaExcludeList() {
          return schemaExcludeList;
      }
  
      public void setSchemaExcludeList(String schemaExcludeList) {
          this.schemaExcludeList = schemaExcludeList;
      }
  
      public String getSchemaHistoryInternalFileFilename() {
          return schemaHistoryInternalFileFilename;
      }
  
      public void setSchemaHistoryInternalFileFilename(
              String schemaHistoryInternalFileFilename) {
          this.schemaHistoryInternalFileFilename = schemaHistoryInternalFileFilename;
      }
  
      public String getSchemaIncludeList() {
          return schemaIncludeList;
      }
  
      public void setSchemaIncludeList(String schemaIncludeList) {
          this.schemaIncludeList = schemaIncludeList;
      }
  
      public String getSchemaNameAdjustmentMode() {
          return schemaNameAdjustmentMode;
      }
  
      public void setSchemaNameAdjustmentMode(String schemaNameAdjustmentMode) {
          this.schemaNameAdjustmentMode = schemaNameAdjustmentMode;
      }
  
      public String getSchemaRefreshMode() {
          return schemaRefreshMode;
      }
  
      public void setSchemaRefreshMode(String schemaRefreshMode) {
          this.schemaRefreshMode = schemaRefreshMode;
      }
  
      public String getSignalDataCollection() {
          return signalDataCollection;
      }
  
      public void setSignalDataCollection(String signalDataCollection) {
          this.signalDataCollection = signalDataCollection;
      }
  
      public String getSignalEnabledChannels() {
          return signalEnabledChannels;
      }
  
      public void setSignalEnabledChannels(String signalEnabledChannels) {
          this.signalEnabledChannels = signalEnabledChannels;
      }
  
      public Long getSignalPollIntervalMs() {
          return signalPollIntervalMs;
      }
  
      public void setSignalPollIntervalMs(Long signalPollIntervalMs) {
          this.signalPollIntervalMs = signalPollIntervalMs;
      }
  
      public String getSkippedOperations() {
          return skippedOperations;
      }
  
      public void setSkippedOperations(String skippedOperations) {
          this.skippedOperations = skippedOperations;
      }
  
      public Boolean getSlotDropOnStop() {
          return slotDropOnStop;
      }
  
      public void setSlotDropOnStop(Boolean slotDropOnStop) {
          this.slotDropOnStop = slotDropOnStop;
      }
  
      public Boolean getSlotFailover() {
          return slotFailover;
      }
  
      public void setSlotFailover(Boolean slotFailover) {
          this.slotFailover = slotFailover;
      }
  
      public Integer getSlotMaxRetries() {
          return slotMaxRetries;
      }
  
      public void setSlotMaxRetries(Integer slotMaxRetries) {
          this.slotMaxRetries = slotMaxRetries;
      }
  
      public String getSlotName() {
          return slotName;
      }
  
      public void setSlotName(String slotName) {
          this.slotName = slotName;
      }
  
      public Long getSlotRetryDelayMs() {
          return slotRetryDelayMs;
      }
  
      public void setSlotRetryDelayMs(Long slotRetryDelayMs) {
          this.slotRetryDelayMs = slotRetryDelayMs;
      }
  
      public String getSlotStreamParams() {
          return slotStreamParams;
      }
  
      public void setSlotStreamParams(String slotStreamParams) {
          this.slotStreamParams = slotStreamParams;
      }
  
      public Long getSnapshotDelayMs() {
          return snapshotDelayMs;
      }
  
      public void setSnapshotDelayMs(Long snapshotDelayMs) {
          this.snapshotDelayMs = snapshotDelayMs;
      }
  
      public Integer getSnapshotFetchSize() {
          return snapshotFetchSize;
      }
  
      public void setSnapshotFetchSize(Integer snapshotFetchSize) {
          this.snapshotFetchSize = snapshotFetchSize;
      }
  
      public String getSnapshotIncludeCollectionList() {
          return snapshotIncludeCollectionList;
      }
  
      public void setSnapshotIncludeCollectionList(
              String snapshotIncludeCollectionList) {
          this.snapshotIncludeCollectionList = snapshotIncludeCollectionList;
      }
  
      public String getSnapshotIsolationMode() {
          return snapshotIsolationMode;
      }
  
      public void setSnapshotIsolationMode(String snapshotIsolationMode) {
          this.snapshotIsolationMode = snapshotIsolationMode;
      }
  
      public String getSnapshotLockingMode() {
          return snapshotLockingMode;
      }
  
      public void setSnapshotLockingMode(String snapshotLockingMode) {
          this.snapshotLockingMode = snapshotLockingMode;
      }
  
      public String getSnapshotLockingModeCustomName() {
          return snapshotLockingModeCustomName;
      }
  
      public void setSnapshotLockingModeCustomName(
              String snapshotLockingModeCustomName) {
          this.snapshotLockingModeCustomName = snapshotLockingModeCustomName;
      }
  
      public Long getSnapshotLockTimeoutMs() {
          return snapshotLockTimeoutMs;
      }
  
      public void setSnapshotLockTimeoutMs(Long snapshotLockTimeoutMs) {
          this.snapshotLockTimeoutMs = snapshotLockTimeoutMs;
      }
  
      public Integer getSnapshotMaxThreads() {
          return snapshotMaxThreads;
      }
  
      public void setSnapshotMaxThreads(Integer snapshotMaxThreads) {
          this.snapshotMaxThreads = snapshotMaxThreads;
      }
  
      public String getSnapshotMode() {
          return snapshotMode;
      }
  
      public void setSnapshotMode(String snapshotMode) {
          this.snapshotMode = snapshotMode;
      }
  
      public Boolean getSnapshotModeConfigurationBasedSnapshotData() {
          return snapshotModeConfigurationBasedSnapshotData;
      }
  
      public void setSnapshotModeConfigurationBasedSnapshotData(
              Boolean snapshotModeConfigurationBasedSnapshotData) {
          this.snapshotModeConfigurationBasedSnapshotData = snapshotModeConfigurationBasedSnapshotData;
      }
  
      public Boolean getSnapshotModeConfigurationBasedSnapshotOnDataError() {
          return snapshotModeConfigurationBasedSnapshotOnDataError;
      }
  
      public void setSnapshotModeConfigurationBasedSnapshotOnDataError(
              Boolean snapshotModeConfigurationBasedSnapshotOnDataError) {
          this.snapshotModeConfigurationBasedSnapshotOnDataError = snapshotModeConfigurationBasedSnapshotOnDataError;
      }
  
      public Boolean getSnapshotModeConfigurationBasedSnapshotOnSchemaError() {
          return snapshotModeConfigurationBasedSnapshotOnSchemaError;
      }
  
      public void setSnapshotModeConfigurationBasedSnapshotOnSchemaError(
              Boolean snapshotModeConfigurationBasedSnapshotOnSchemaError) {
          this.snapshotModeConfigurationBasedSnapshotOnSchemaError = snapshotModeConfigurationBasedSnapshotOnSchemaError;
      }
  
      public Boolean getSnapshotModeConfigurationBasedSnapshotSchema() {
          return snapshotModeConfigurationBasedSnapshotSchema;
      }
  
      public void setSnapshotModeConfigurationBasedSnapshotSchema(
              Boolean snapshotModeConfigurationBasedSnapshotSchema) {
          this.snapshotModeConfigurationBasedSnapshotSchema = snapshotModeConfigurationBasedSnapshotSchema;
      }
  
      public Boolean getSnapshotModeConfigurationBasedStartStream() {
          return snapshotModeConfigurationBasedStartStream;
      }
  
      public void setSnapshotModeConfigurationBasedStartStream(
              Boolean snapshotModeConfigurationBasedStartStream) {
          this.snapshotModeConfigurationBasedStartStream = snapshotModeConfigurationBasedStartStream;
      }
  
      public String getSnapshotModeCustomName() {
          return snapshotModeCustomName;
      }
  
      public void setSnapshotModeCustomName(String snapshotModeCustomName) {
          this.snapshotModeCustomName = snapshotModeCustomName;
      }
  
      public String getSnapshotQueryMode() {
          return snapshotQueryMode;
      }
  
      public void setSnapshotQueryMode(String snapshotQueryMode) {
          this.snapshotQueryMode = snapshotQueryMode;
      }
  
      public String getSnapshotQueryModeCustomName() {
          return snapshotQueryModeCustomName;
      }
  
      public void setSnapshotQueryModeCustomName(
              String snapshotQueryModeCustomName) {
          this.snapshotQueryModeCustomName = snapshotQueryModeCustomName;
      }
  
      public String getSnapshotSelectStatementOverrides() {
          return snapshotSelectStatementOverrides;
      }
  
      public void setSnapshotSelectStatementOverrides(
              String snapshotSelectStatementOverrides) {
          this.snapshotSelectStatementOverrides = snapshotSelectStatementOverrides;
      }
  
      public String getSnapshotTablesOrderByRowCount() {
          return snapshotTablesOrderByRowCount;
      }
  
      public void setSnapshotTablesOrderByRowCount(
              String snapshotTablesOrderByRowCount) {
          this.snapshotTablesOrderByRowCount = snapshotTablesOrderByRowCount;
      }
  
      public String getSourceinfoStructMaker() {
          return sourceinfoStructMaker;
      }
  
      public void setSourceinfoStructMaker(String sourceinfoStructMaker) {
          this.sourceinfoStructMaker = sourceinfoStructMaker;
      }
  
      public Integer getStatusUpdateIntervalMs() {
          return statusUpdateIntervalMs;
      }
  
      public void setStatusUpdateIntervalMs(Integer statusUpdateIntervalMs) {
          this.statusUpdateIntervalMs = statusUpdateIntervalMs;
      }
  
      public Long getStreamingDelayMs() {
          return streamingDelayMs;
      }
  
      public void setStreamingDelayMs(Long streamingDelayMs) {
          this.streamingDelayMs = streamingDelayMs;
      }
  
      public String getTableExcludeList() {
          return tableExcludeList;
      }
  
      public void setTableExcludeList(String tableExcludeList) {
          this.tableExcludeList = tableExcludeList;
      }
  
      public Boolean getTableIgnoreBuiltin() {
          return tableIgnoreBuiltin;
      }
  
      public void setTableIgnoreBuiltin(Boolean tableIgnoreBuiltin) {
          this.tableIgnoreBuiltin = tableIgnoreBuiltin;
      }
  
      public String getTableIncludeList() {
          return tableIncludeList;
      }
  
      public void setTableIncludeList(String tableIncludeList) {
          this.tableIncludeList = tableIncludeList;
      }
  
      public String getTimePrecisionMode() {
          return timePrecisionMode;
      }
  
      public void setTimePrecisionMode(String timePrecisionMode) {
          this.timePrecisionMode = timePrecisionMode;
      }
  
      public Boolean getTombstonesOnDelete() {
          return tombstonesOnDelete;
      }
  
      public void setTombstonesOnDelete(Boolean tombstonesOnDelete) {
          this.tombstonesOnDelete = tombstonesOnDelete;
      }
  
      public String getTopicNamingStrategy() {
          return topicNamingStrategy;
      }
  
      public void setTopicNamingStrategy(String topicNamingStrategy) {
          this.topicNamingStrategy = topicNamingStrategy;
      }
  
      public String getTopicPrefix() {
          return topicPrefix;
      }
  
      public void setTopicPrefix(String topicPrefix) {
          this.topicPrefix = topicPrefix;
      }
  
      public String getTransactionMetadataFactory() {
          return transactionMetadataFactory;
      }
  
      public void setTransactionMetadataFactory(String transactionMetadataFactory) {
          this.transactionMetadataFactory = transactionMetadataFactory;
      }
  
      public String getUnavailableValuePlaceholder() {
          return unavailableValuePlaceholder;
      }
  
      public void setUnavailableValuePlaceholder(
              String unavailableValuePlaceholder) {
          this.unavailableValuePlaceholder = unavailableValuePlaceholder;
      }
  
      public Long getXminFetchIntervalMs() {
          return xminFetchIntervalMs;
      }
  
      public void setXminFetchIntervalMs(Long xminFetchIntervalMs) {
          this.xminFetchIntervalMs = xminFetchIntervalMs;
      }
  }