# coding=utf-8
# *** WARNING: this file was generated by the Pulumi SDK Generator. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from ._enums import *

__all__ = [
    'DeliveryStreamBufferingHintsArgs',
    'DeliveryStreamCloudWatchLoggingOptionsArgs',
    'DeliveryStreamCopyCommandArgs',
    'DeliveryStreamDataFormatConversionConfigurationArgs',
    'DeliveryStreamDeliveryStreamEncryptionConfigurationInputArgs',
    'DeliveryStreamDeserializerArgs',
    'DeliveryStreamDynamicPartitioningConfigurationArgs',
    'DeliveryStreamElasticsearchBufferingHintsArgs',
    'DeliveryStreamElasticsearchDestinationConfigurationArgs',
    'DeliveryStreamElasticsearchRetryOptionsArgs',
    'DeliveryStreamEncryptionConfigurationArgs',
    'DeliveryStreamExtendedS3DestinationConfigurationArgs',
    'DeliveryStreamHiveJsonSerDeArgs',
    'DeliveryStreamHttpEndpointCommonAttributeArgs',
    'DeliveryStreamHttpEndpointConfigurationArgs',
    'DeliveryStreamHttpEndpointDestinationConfigurationArgs',
    'DeliveryStreamHttpEndpointRequestConfigurationArgs',
    'DeliveryStreamInputFormatConfigurationArgs',
    'DeliveryStreamKMSEncryptionConfigArgs',
    'DeliveryStreamKinesisStreamSourceConfigurationArgs',
    'DeliveryStreamOpenXJsonSerDeArgs',
    'DeliveryStreamOrcSerDeArgs',
    'DeliveryStreamOutputFormatConfigurationArgs',
    'DeliveryStreamParquetSerDeArgs',
    'DeliveryStreamProcessingConfigurationArgs',
    'DeliveryStreamProcessorParameterArgs',
    'DeliveryStreamProcessorArgs',
    'DeliveryStreamRedshiftDestinationConfigurationArgs',
    'DeliveryStreamRedshiftRetryOptionsArgs',
    'DeliveryStreamRetryOptionsArgs',
    'DeliveryStreamS3DestinationConfigurationArgs',
    'DeliveryStreamSchemaConfigurationArgs',
    'DeliveryStreamSerializerArgs',
    'DeliveryStreamSplunkDestinationConfigurationArgs',
    'DeliveryStreamSplunkRetryOptionsArgs',
    'DeliveryStreamTagArgs',
    'DeliveryStreamVpcConfigurationArgs',
]

@pulumi.input_type
class DeliveryStreamBufferingHintsArgs:
    def __init__(__self__, *,
                 interval_in_seconds: Optional[pulumi.Input[int]] = None,
                 size_in_mbs: Optional[pulumi.Input[int]] = None):
        if interval_in_seconds is not None:
            pulumi.set(__self__, "interval_in_seconds", interval_in_seconds)
        if size_in_mbs is not None:
            pulumi.set(__self__, "size_in_mbs", size_in_mbs)

    @property
    @pulumi.getter(name="intervalInSeconds")
    def interval_in_seconds(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "interval_in_seconds")

    @interval_in_seconds.setter
    def interval_in_seconds(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "interval_in_seconds", value)

    @property
    @pulumi.getter(name="sizeInMBs")
    def size_in_mbs(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "size_in_mbs")

    @size_in_mbs.setter
    def size_in_mbs(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "size_in_mbs", value)


@pulumi.input_type
class DeliveryStreamCloudWatchLoggingOptionsArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 log_group_name: Optional[pulumi.Input[str]] = None,
                 log_stream_name: Optional[pulumi.Input[str]] = None):
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if log_group_name is not None:
            pulumi.set(__self__, "log_group_name", log_group_name)
        if log_stream_name is not None:
            pulumi.set(__self__, "log_stream_name", log_stream_name)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter(name="logGroupName")
    def log_group_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "log_group_name")

    @log_group_name.setter
    def log_group_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "log_group_name", value)

    @property
    @pulumi.getter(name="logStreamName")
    def log_stream_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "log_stream_name")

    @log_stream_name.setter
    def log_stream_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "log_stream_name", value)


@pulumi.input_type
class DeliveryStreamCopyCommandArgs:
    def __init__(__self__, *,
                 data_table_name: pulumi.Input[str],
                 copy_options: Optional[pulumi.Input[str]] = None,
                 data_table_columns: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "data_table_name", data_table_name)
        if copy_options is not None:
            pulumi.set(__self__, "copy_options", copy_options)
        if data_table_columns is not None:
            pulumi.set(__self__, "data_table_columns", data_table_columns)

    @property
    @pulumi.getter(name="dataTableName")
    def data_table_name(self) -> pulumi.Input[str]:
        return pulumi.get(self, "data_table_name")

    @data_table_name.setter
    def data_table_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "data_table_name", value)

    @property
    @pulumi.getter(name="copyOptions")
    def copy_options(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "copy_options")

    @copy_options.setter
    def copy_options(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "copy_options", value)

    @property
    @pulumi.getter(name="dataTableColumns")
    def data_table_columns(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "data_table_columns")

    @data_table_columns.setter
    def data_table_columns(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "data_table_columns", value)


@pulumi.input_type
class DeliveryStreamDataFormatConversionConfigurationArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 input_format_configuration: Optional[pulumi.Input['DeliveryStreamInputFormatConfigurationArgs']] = None,
                 output_format_configuration: Optional[pulumi.Input['DeliveryStreamOutputFormatConfigurationArgs']] = None,
                 schema_configuration: Optional[pulumi.Input['DeliveryStreamSchemaConfigurationArgs']] = None):
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if input_format_configuration is not None:
            pulumi.set(__self__, "input_format_configuration", input_format_configuration)
        if output_format_configuration is not None:
            pulumi.set(__self__, "output_format_configuration", output_format_configuration)
        if schema_configuration is not None:
            pulumi.set(__self__, "schema_configuration", schema_configuration)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter(name="inputFormatConfiguration")
    def input_format_configuration(self) -> Optional[pulumi.Input['DeliveryStreamInputFormatConfigurationArgs']]:
        return pulumi.get(self, "input_format_configuration")

    @input_format_configuration.setter
    def input_format_configuration(self, value: Optional[pulumi.Input['DeliveryStreamInputFormatConfigurationArgs']]):
        pulumi.set(self, "input_format_configuration", value)

    @property
    @pulumi.getter(name="outputFormatConfiguration")
    def output_format_configuration(self) -> Optional[pulumi.Input['DeliveryStreamOutputFormatConfigurationArgs']]:
        return pulumi.get(self, "output_format_configuration")

    @output_format_configuration.setter
    def output_format_configuration(self, value: Optional[pulumi.Input['DeliveryStreamOutputFormatConfigurationArgs']]):
        pulumi.set(self, "output_format_configuration", value)

    @property
    @pulumi.getter(name="schemaConfiguration")
    def schema_configuration(self) -> Optional[pulumi.Input['DeliveryStreamSchemaConfigurationArgs']]:
        return pulumi.get(self, "schema_configuration")

    @schema_configuration.setter
    def schema_configuration(self, value: Optional[pulumi.Input['DeliveryStreamSchemaConfigurationArgs']]):
        pulumi.set(self, "schema_configuration", value)


@pulumi.input_type
class DeliveryStreamDeliveryStreamEncryptionConfigurationInputArgs:
    def __init__(__self__, *,
                 key_type: pulumi.Input['DeliveryStreamDeliveryStreamEncryptionConfigurationInputKeyType'],
                 key_arn: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "key_type", key_type)
        if key_arn is not None:
            pulumi.set(__self__, "key_arn", key_arn)

    @property
    @pulumi.getter(name="keyType")
    def key_type(self) -> pulumi.Input['DeliveryStreamDeliveryStreamEncryptionConfigurationInputKeyType']:
        return pulumi.get(self, "key_type")

    @key_type.setter
    def key_type(self, value: pulumi.Input['DeliveryStreamDeliveryStreamEncryptionConfigurationInputKeyType']):
        pulumi.set(self, "key_type", value)

    @property
    @pulumi.getter(name="keyARN")
    def key_arn(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "key_arn")

    @key_arn.setter
    def key_arn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key_arn", value)


@pulumi.input_type
class DeliveryStreamDeserializerArgs:
    def __init__(__self__, *,
                 hive_json_ser_de: Optional[pulumi.Input['DeliveryStreamHiveJsonSerDeArgs']] = None,
                 open_x_json_ser_de: Optional[pulumi.Input['DeliveryStreamOpenXJsonSerDeArgs']] = None):
        if hive_json_ser_de is not None:
            pulumi.set(__self__, "hive_json_ser_de", hive_json_ser_de)
        if open_x_json_ser_de is not None:
            pulumi.set(__self__, "open_x_json_ser_de", open_x_json_ser_de)

    @property
    @pulumi.getter(name="hiveJsonSerDe")
    def hive_json_ser_de(self) -> Optional[pulumi.Input['DeliveryStreamHiveJsonSerDeArgs']]:
        return pulumi.get(self, "hive_json_ser_de")

    @hive_json_ser_de.setter
    def hive_json_ser_de(self, value: Optional[pulumi.Input['DeliveryStreamHiveJsonSerDeArgs']]):
        pulumi.set(self, "hive_json_ser_de", value)

    @property
    @pulumi.getter(name="openXJsonSerDe")
    def open_x_json_ser_de(self) -> Optional[pulumi.Input['DeliveryStreamOpenXJsonSerDeArgs']]:
        return pulumi.get(self, "open_x_json_ser_de")

    @open_x_json_ser_de.setter
    def open_x_json_ser_de(self, value: Optional[pulumi.Input['DeliveryStreamOpenXJsonSerDeArgs']]):
        pulumi.set(self, "open_x_json_ser_de", value)


@pulumi.input_type
class DeliveryStreamDynamicPartitioningConfigurationArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 retry_options: Optional[pulumi.Input['DeliveryStreamRetryOptionsArgs']] = None):
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if retry_options is not None:
            pulumi.set(__self__, "retry_options", retry_options)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter(name="retryOptions")
    def retry_options(self) -> Optional[pulumi.Input['DeliveryStreamRetryOptionsArgs']]:
        return pulumi.get(self, "retry_options")

    @retry_options.setter
    def retry_options(self, value: Optional[pulumi.Input['DeliveryStreamRetryOptionsArgs']]):
        pulumi.set(self, "retry_options", value)


@pulumi.input_type
class DeliveryStreamElasticsearchBufferingHintsArgs:
    def __init__(__self__, *,
                 interval_in_seconds: Optional[pulumi.Input[int]] = None,
                 size_in_mbs: Optional[pulumi.Input[int]] = None):
        if interval_in_seconds is not None:
            pulumi.set(__self__, "interval_in_seconds", interval_in_seconds)
        if size_in_mbs is not None:
            pulumi.set(__self__, "size_in_mbs", size_in_mbs)

    @property
    @pulumi.getter(name="intervalInSeconds")
    def interval_in_seconds(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "interval_in_seconds")

    @interval_in_seconds.setter
    def interval_in_seconds(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "interval_in_seconds", value)

    @property
    @pulumi.getter(name="sizeInMBs")
    def size_in_mbs(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "size_in_mbs")

    @size_in_mbs.setter
    def size_in_mbs(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "size_in_mbs", value)


@pulumi.input_type
class DeliveryStreamElasticsearchDestinationConfigurationArgs:
    def __init__(__self__, *,
                 index_name: pulumi.Input[str],
                 role_arn: pulumi.Input[str],
                 s3_configuration: pulumi.Input['DeliveryStreamS3DestinationConfigurationArgs'],
                 buffering_hints: Optional[pulumi.Input['DeliveryStreamElasticsearchBufferingHintsArgs']] = None,
                 cloud_watch_logging_options: Optional[pulumi.Input['DeliveryStreamCloudWatchLoggingOptionsArgs']] = None,
                 cluster_endpoint: Optional[pulumi.Input[str]] = None,
                 domain_arn: Optional[pulumi.Input[str]] = None,
                 index_rotation_period: Optional[pulumi.Input['DeliveryStreamElasticsearchDestinationConfigurationIndexRotationPeriod']] = None,
                 processing_configuration: Optional[pulumi.Input['DeliveryStreamProcessingConfigurationArgs']] = None,
                 retry_options: Optional[pulumi.Input['DeliveryStreamElasticsearchRetryOptionsArgs']] = None,
                 s3_backup_mode: Optional[pulumi.Input['DeliveryStreamElasticsearchDestinationConfigurationS3BackupMode']] = None,
                 type_name: Optional[pulumi.Input[str]] = None,
                 vpc_configuration: Optional[pulumi.Input['DeliveryStreamVpcConfigurationArgs']] = None):
        pulumi.set(__self__, "index_name", index_name)
        pulumi.set(__self__, "role_arn", role_arn)
        pulumi.set(__self__, "s3_configuration", s3_configuration)
        if buffering_hints is not None:
            pulumi.set(__self__, "buffering_hints", buffering_hints)
        if cloud_watch_logging_options is not None:
            pulumi.set(__self__, "cloud_watch_logging_options", cloud_watch_logging_options)
        if cluster_endpoint is not None:
            pulumi.set(__self__, "cluster_endpoint", cluster_endpoint)
        if domain_arn is not None:
            pulumi.set(__self__, "domain_arn", domain_arn)
        if index_rotation_period is not None:
            pulumi.set(__self__, "index_rotation_period", index_rotation_period)
        if processing_configuration is not None:
            pulumi.set(__self__, "processing_configuration", processing_configuration)
        if retry_options is not None:
            pulumi.set(__self__, "retry_options", retry_options)
        if s3_backup_mode is not None:
            pulumi.set(__self__, "s3_backup_mode", s3_backup_mode)
        if type_name is not None:
            pulumi.set(__self__, "type_name", type_name)
        if vpc_configuration is not None:
            pulumi.set(__self__, "vpc_configuration", vpc_configuration)

    @property
    @pulumi.getter(name="indexName")
    def index_name(self) -> pulumi.Input[str]:
        return pulumi.get(self, "index_name")

    @index_name.setter
    def index_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "index_name", value)

    @property
    @pulumi.getter(name="roleARN")
    def role_arn(self) -> pulumi.Input[str]:
        return pulumi.get(self, "role_arn")

    @role_arn.setter
    def role_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "role_arn", value)

    @property
    @pulumi.getter(name="s3Configuration")
    def s3_configuration(self) -> pulumi.Input['DeliveryStreamS3DestinationConfigurationArgs']:
        return pulumi.get(self, "s3_configuration")

    @s3_configuration.setter
    def s3_configuration(self, value: pulumi.Input['DeliveryStreamS3DestinationConfigurationArgs']):
        pulumi.set(self, "s3_configuration", value)

    @property
    @pulumi.getter(name="bufferingHints")
    def buffering_hints(self) -> Optional[pulumi.Input['DeliveryStreamElasticsearchBufferingHintsArgs']]:
        return pulumi.get(self, "buffering_hints")

    @buffering_hints.setter
    def buffering_hints(self, value: Optional[pulumi.Input['DeliveryStreamElasticsearchBufferingHintsArgs']]):
        pulumi.set(self, "buffering_hints", value)

    @property
    @pulumi.getter(name="cloudWatchLoggingOptions")
    def cloud_watch_logging_options(self) -> Optional[pulumi.Input['DeliveryStreamCloudWatchLoggingOptionsArgs']]:
        return pulumi.get(self, "cloud_watch_logging_options")

    @cloud_watch_logging_options.setter
    def cloud_watch_logging_options(self, value: Optional[pulumi.Input['DeliveryStreamCloudWatchLoggingOptionsArgs']]):
        pulumi.set(self, "cloud_watch_logging_options", value)

    @property
    @pulumi.getter(name="clusterEndpoint")
    def cluster_endpoint(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "cluster_endpoint")

    @cluster_endpoint.setter
    def cluster_endpoint(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cluster_endpoint", value)

    @property
    @pulumi.getter(name="domainARN")
    def domain_arn(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "domain_arn")

    @domain_arn.setter
    def domain_arn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "domain_arn", value)

    @property
    @pulumi.getter(name="indexRotationPeriod")
    def index_rotation_period(self) -> Optional[pulumi.Input['DeliveryStreamElasticsearchDestinationConfigurationIndexRotationPeriod']]:
        return pulumi.get(self, "index_rotation_period")

    @index_rotation_period.setter
    def index_rotation_period(self, value: Optional[pulumi.Input['DeliveryStreamElasticsearchDestinationConfigurationIndexRotationPeriod']]):
        pulumi.set(self, "index_rotation_period", value)

    @property
    @pulumi.getter(name="processingConfiguration")
    def processing_configuration(self) -> Optional[pulumi.Input['DeliveryStreamProcessingConfigurationArgs']]:
        return pulumi.get(self, "processing_configuration")

    @processing_configuration.setter
    def processing_configuration(self, value: Optional[pulumi.Input['DeliveryStreamProcessingConfigurationArgs']]):
        pulumi.set(self, "processing_configuration", value)

    @property
    @pulumi.getter(name="retryOptions")
    def retry_options(self) -> Optional[pulumi.Input['DeliveryStreamElasticsearchRetryOptionsArgs']]:
        return pulumi.get(self, "retry_options")

    @retry_options.setter
    def retry_options(self, value: Optional[pulumi.Input['DeliveryStreamElasticsearchRetryOptionsArgs']]):
        pulumi.set(self, "retry_options", value)

    @property
    @pulumi.getter(name="s3BackupMode")
    def s3_backup_mode(self) -> Optional[pulumi.Input['DeliveryStreamElasticsearchDestinationConfigurationS3BackupMode']]:
        return pulumi.get(self, "s3_backup_mode")

    @s3_backup_mode.setter
    def s3_backup_mode(self, value: Optional[pulumi.Input['DeliveryStreamElasticsearchDestinationConfigurationS3BackupMode']]):
        pulumi.set(self, "s3_backup_mode", value)

    @property
    @pulumi.getter(name="typeName")
    def type_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "type_name")

    @type_name.setter
    def type_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "type_name", value)

    @property
    @pulumi.getter(name="vpcConfiguration")
    def vpc_configuration(self) -> Optional[pulumi.Input['DeliveryStreamVpcConfigurationArgs']]:
        return pulumi.get(self, "vpc_configuration")

    @vpc_configuration.setter
    def vpc_configuration(self, value: Optional[pulumi.Input['DeliveryStreamVpcConfigurationArgs']]):
        pulumi.set(self, "vpc_configuration", value)


@pulumi.input_type
class DeliveryStreamElasticsearchRetryOptionsArgs:
    def __init__(__self__, *,
                 duration_in_seconds: Optional[pulumi.Input[int]] = None):
        if duration_in_seconds is not None:
            pulumi.set(__self__, "duration_in_seconds", duration_in_seconds)

    @property
    @pulumi.getter(name="durationInSeconds")
    def duration_in_seconds(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "duration_in_seconds")

    @duration_in_seconds.setter
    def duration_in_seconds(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "duration_in_seconds", value)


@pulumi.input_type
class DeliveryStreamEncryptionConfigurationArgs:
    def __init__(__self__, *,
                 k_ms_encryption_config: Optional[pulumi.Input['DeliveryStreamKMSEncryptionConfigArgs']] = None,
                 no_encryption_config: Optional[pulumi.Input['DeliveryStreamEncryptionConfigurationNoEncryptionConfig']] = None):
        if k_ms_encryption_config is not None:
            pulumi.set(__self__, "k_ms_encryption_config", k_ms_encryption_config)
        if no_encryption_config is not None:
            pulumi.set(__self__, "no_encryption_config", no_encryption_config)

    @property
    @pulumi.getter(name="kMSEncryptionConfig")
    def k_ms_encryption_config(self) -> Optional[pulumi.Input['DeliveryStreamKMSEncryptionConfigArgs']]:
        return pulumi.get(self, "k_ms_encryption_config")

    @k_ms_encryption_config.setter
    def k_ms_encryption_config(self, value: Optional[pulumi.Input['DeliveryStreamKMSEncryptionConfigArgs']]):
        pulumi.set(self, "k_ms_encryption_config", value)

    @property
    @pulumi.getter(name="noEncryptionConfig")
    def no_encryption_config(self) -> Optional[pulumi.Input['DeliveryStreamEncryptionConfigurationNoEncryptionConfig']]:
        return pulumi.get(self, "no_encryption_config")

    @no_encryption_config.setter
    def no_encryption_config(self, value: Optional[pulumi.Input['DeliveryStreamEncryptionConfigurationNoEncryptionConfig']]):
        pulumi.set(self, "no_encryption_config", value)


@pulumi.input_type
class DeliveryStreamExtendedS3DestinationConfigurationArgs:
    def __init__(__self__, *,
                 bucket_arn: pulumi.Input[str],
                 role_arn: pulumi.Input[str],
                 buffering_hints: Optional[pulumi.Input['DeliveryStreamBufferingHintsArgs']] = None,
                 cloud_watch_logging_options: Optional[pulumi.Input['DeliveryStreamCloudWatchLoggingOptionsArgs']] = None,
                 compression_format: Optional[pulumi.Input['DeliveryStreamExtendedS3DestinationConfigurationCompressionFormat']] = None,
                 data_format_conversion_configuration: Optional[pulumi.Input['DeliveryStreamDataFormatConversionConfigurationArgs']] = None,
                 dynamic_partitioning_configuration: Optional[pulumi.Input['DeliveryStreamDynamicPartitioningConfigurationArgs']] = None,
                 encryption_configuration: Optional[pulumi.Input['DeliveryStreamEncryptionConfigurationArgs']] = None,
                 error_output_prefix: Optional[pulumi.Input[str]] = None,
                 prefix: Optional[pulumi.Input[str]] = None,
                 processing_configuration: Optional[pulumi.Input['DeliveryStreamProcessingConfigurationArgs']] = None,
                 s3_backup_configuration: Optional[pulumi.Input['DeliveryStreamS3DestinationConfigurationArgs']] = None,
                 s3_backup_mode: Optional[pulumi.Input['DeliveryStreamExtendedS3DestinationConfigurationS3BackupMode']] = None):
        pulumi.set(__self__, "bucket_arn", bucket_arn)
        pulumi.set(__self__, "role_arn", role_arn)
        if buffering_hints is not None:
            pulumi.set(__self__, "buffering_hints", buffering_hints)
        if cloud_watch_logging_options is not None:
            pulumi.set(__self__, "cloud_watch_logging_options", cloud_watch_logging_options)
        if compression_format is not None:
            pulumi.set(__self__, "compression_format", compression_format)
        if data_format_conversion_configuration is not None:
            pulumi.set(__self__, "data_format_conversion_configuration", data_format_conversion_configuration)
        if dynamic_partitioning_configuration is not None:
            pulumi.set(__self__, "dynamic_partitioning_configuration", dynamic_partitioning_configuration)
        if encryption_configuration is not None:
            pulumi.set(__self__, "encryption_configuration", encryption_configuration)
        if error_output_prefix is not None:
            pulumi.set(__self__, "error_output_prefix", error_output_prefix)
        if prefix is not None:
            pulumi.set(__self__, "prefix", prefix)
        if processing_configuration is not None:
            pulumi.set(__self__, "processing_configuration", processing_configuration)
        if s3_backup_configuration is not None:
            pulumi.set(__self__, "s3_backup_configuration", s3_backup_configuration)
        if s3_backup_mode is not None:
            pulumi.set(__self__, "s3_backup_mode", s3_backup_mode)

    @property
    @pulumi.getter(name="bucketARN")
    def bucket_arn(self) -> pulumi.Input[str]:
        return pulumi.get(self, "bucket_arn")

    @bucket_arn.setter
    def bucket_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "bucket_arn", value)

    @property
    @pulumi.getter(name="roleARN")
    def role_arn(self) -> pulumi.Input[str]:
        return pulumi.get(self, "role_arn")

    @role_arn.setter
    def role_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "role_arn", value)

    @property
    @pulumi.getter(name="bufferingHints")
    def buffering_hints(self) -> Optional[pulumi.Input['DeliveryStreamBufferingHintsArgs']]:
        return pulumi.get(self, "buffering_hints")

    @buffering_hints.setter
    def buffering_hints(self, value: Optional[pulumi.Input['DeliveryStreamBufferingHintsArgs']]):
        pulumi.set(self, "buffering_hints", value)

    @property
    @pulumi.getter(name="cloudWatchLoggingOptions")
    def cloud_watch_logging_options(self) -> Optional[pulumi.Input['DeliveryStreamCloudWatchLoggingOptionsArgs']]:
        return pulumi.get(self, "cloud_watch_logging_options")

    @cloud_watch_logging_options.setter
    def cloud_watch_logging_options(self, value: Optional[pulumi.Input['DeliveryStreamCloudWatchLoggingOptionsArgs']]):
        pulumi.set(self, "cloud_watch_logging_options", value)

    @property
    @pulumi.getter(name="compressionFormat")
    def compression_format(self) -> Optional[pulumi.Input['DeliveryStreamExtendedS3DestinationConfigurationCompressionFormat']]:
        return pulumi.get(self, "compression_format")

    @compression_format.setter
    def compression_format(self, value: Optional[pulumi.Input['DeliveryStreamExtendedS3DestinationConfigurationCompressionFormat']]):
        pulumi.set(self, "compression_format", value)

    @property
    @pulumi.getter(name="dataFormatConversionConfiguration")
    def data_format_conversion_configuration(self) -> Optional[pulumi.Input['DeliveryStreamDataFormatConversionConfigurationArgs']]:
        return pulumi.get(self, "data_format_conversion_configuration")

    @data_format_conversion_configuration.setter
    def data_format_conversion_configuration(self, value: Optional[pulumi.Input['DeliveryStreamDataFormatConversionConfigurationArgs']]):
        pulumi.set(self, "data_format_conversion_configuration", value)

    @property
    @pulumi.getter(name="dynamicPartitioningConfiguration")
    def dynamic_partitioning_configuration(self) -> Optional[pulumi.Input['DeliveryStreamDynamicPartitioningConfigurationArgs']]:
        return pulumi.get(self, "dynamic_partitioning_configuration")

    @dynamic_partitioning_configuration.setter
    def dynamic_partitioning_configuration(self, value: Optional[pulumi.Input['DeliveryStreamDynamicPartitioningConfigurationArgs']]):
        pulumi.set(self, "dynamic_partitioning_configuration", value)

    @property
    @pulumi.getter(name="encryptionConfiguration")
    def encryption_configuration(self) -> Optional[pulumi.Input['DeliveryStreamEncryptionConfigurationArgs']]:
        return pulumi.get(self, "encryption_configuration")

    @encryption_configuration.setter
    def encryption_configuration(self, value: Optional[pulumi.Input['DeliveryStreamEncryptionConfigurationArgs']]):
        pulumi.set(self, "encryption_configuration", value)

    @property
    @pulumi.getter(name="errorOutputPrefix")
    def error_output_prefix(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "error_output_prefix")

    @error_output_prefix.setter
    def error_output_prefix(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "error_output_prefix", value)

    @property
    @pulumi.getter
    def prefix(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "prefix")

    @prefix.setter
    def prefix(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "prefix", value)

    @property
    @pulumi.getter(name="processingConfiguration")
    def processing_configuration(self) -> Optional[pulumi.Input['DeliveryStreamProcessingConfigurationArgs']]:
        return pulumi.get(self, "processing_configuration")

    @processing_configuration.setter
    def processing_configuration(self, value: Optional[pulumi.Input['DeliveryStreamProcessingConfigurationArgs']]):
        pulumi.set(self, "processing_configuration", value)

    @property
    @pulumi.getter(name="s3BackupConfiguration")
    def s3_backup_configuration(self) -> Optional[pulumi.Input['DeliveryStreamS3DestinationConfigurationArgs']]:
        return pulumi.get(self, "s3_backup_configuration")

    @s3_backup_configuration.setter
    def s3_backup_configuration(self, value: Optional[pulumi.Input['DeliveryStreamS3DestinationConfigurationArgs']]):
        pulumi.set(self, "s3_backup_configuration", value)

    @property
    @pulumi.getter(name="s3BackupMode")
    def s3_backup_mode(self) -> Optional[pulumi.Input['DeliveryStreamExtendedS3DestinationConfigurationS3BackupMode']]:
        return pulumi.get(self, "s3_backup_mode")

    @s3_backup_mode.setter
    def s3_backup_mode(self, value: Optional[pulumi.Input['DeliveryStreamExtendedS3DestinationConfigurationS3BackupMode']]):
        pulumi.set(self, "s3_backup_mode", value)


@pulumi.input_type
class DeliveryStreamHiveJsonSerDeArgs:
    def __init__(__self__, *,
                 timestamp_formats: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        if timestamp_formats is not None:
            pulumi.set(__self__, "timestamp_formats", timestamp_formats)

    @property
    @pulumi.getter(name="timestampFormats")
    def timestamp_formats(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "timestamp_formats")

    @timestamp_formats.setter
    def timestamp_formats(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "timestamp_formats", value)


@pulumi.input_type
class DeliveryStreamHttpEndpointCommonAttributeArgs:
    def __init__(__self__, *,
                 attribute_name: pulumi.Input[str],
                 attribute_value: pulumi.Input[str]):
        pulumi.set(__self__, "attribute_name", attribute_name)
        pulumi.set(__self__, "attribute_value", attribute_value)

    @property
    @pulumi.getter(name="attributeName")
    def attribute_name(self) -> pulumi.Input[str]:
        return pulumi.get(self, "attribute_name")

    @attribute_name.setter
    def attribute_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "attribute_name", value)

    @property
    @pulumi.getter(name="attributeValue")
    def attribute_value(self) -> pulumi.Input[str]:
        return pulumi.get(self, "attribute_value")

    @attribute_value.setter
    def attribute_value(self, value: pulumi.Input[str]):
        pulumi.set(self, "attribute_value", value)


@pulumi.input_type
class DeliveryStreamHttpEndpointConfigurationArgs:
    def __init__(__self__, *,
                 url: pulumi.Input[str],
                 access_key: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "url", url)
        if access_key is not None:
            pulumi.set(__self__, "access_key", access_key)
        if name is not None:
            pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def url(self) -> pulumi.Input[str]:
        return pulumi.get(self, "url")

    @url.setter
    def url(self, value: pulumi.Input[str]):
        pulumi.set(self, "url", value)

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "access_key")

    @access_key.setter
    def access_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "access_key", value)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)


@pulumi.input_type
class DeliveryStreamHttpEndpointDestinationConfigurationArgs:
    def __init__(__self__, *,
                 endpoint_configuration: pulumi.Input['DeliveryStreamHttpEndpointConfigurationArgs'],
                 s3_configuration: pulumi.Input['DeliveryStreamS3DestinationConfigurationArgs'],
                 buffering_hints: Optional[pulumi.Input['DeliveryStreamBufferingHintsArgs']] = None,
                 cloud_watch_logging_options: Optional[pulumi.Input['DeliveryStreamCloudWatchLoggingOptionsArgs']] = None,
                 processing_configuration: Optional[pulumi.Input['DeliveryStreamProcessingConfigurationArgs']] = None,
                 request_configuration: Optional[pulumi.Input['DeliveryStreamHttpEndpointRequestConfigurationArgs']] = None,
                 retry_options: Optional[pulumi.Input['DeliveryStreamRetryOptionsArgs']] = None,
                 role_arn: Optional[pulumi.Input[str]] = None,
                 s3_backup_mode: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "endpoint_configuration", endpoint_configuration)
        pulumi.set(__self__, "s3_configuration", s3_configuration)
        if buffering_hints is not None:
            pulumi.set(__self__, "buffering_hints", buffering_hints)
        if cloud_watch_logging_options is not None:
            pulumi.set(__self__, "cloud_watch_logging_options", cloud_watch_logging_options)
        if processing_configuration is not None:
            pulumi.set(__self__, "processing_configuration", processing_configuration)
        if request_configuration is not None:
            pulumi.set(__self__, "request_configuration", request_configuration)
        if retry_options is not None:
            pulumi.set(__self__, "retry_options", retry_options)
        if role_arn is not None:
            pulumi.set(__self__, "role_arn", role_arn)
        if s3_backup_mode is not None:
            pulumi.set(__self__, "s3_backup_mode", s3_backup_mode)

    @property
    @pulumi.getter(name="endpointConfiguration")
    def endpoint_configuration(self) -> pulumi.Input['DeliveryStreamHttpEndpointConfigurationArgs']:
        return pulumi.get(self, "endpoint_configuration")

    @endpoint_configuration.setter
    def endpoint_configuration(self, value: pulumi.Input['DeliveryStreamHttpEndpointConfigurationArgs']):
        pulumi.set(self, "endpoint_configuration", value)

    @property
    @pulumi.getter(name="s3Configuration")
    def s3_configuration(self) -> pulumi.Input['DeliveryStreamS3DestinationConfigurationArgs']:
        return pulumi.get(self, "s3_configuration")

    @s3_configuration.setter
    def s3_configuration(self, value: pulumi.Input['DeliveryStreamS3DestinationConfigurationArgs']):
        pulumi.set(self, "s3_configuration", value)

    @property
    @pulumi.getter(name="bufferingHints")
    def buffering_hints(self) -> Optional[pulumi.Input['DeliveryStreamBufferingHintsArgs']]:
        return pulumi.get(self, "buffering_hints")

    @buffering_hints.setter
    def buffering_hints(self, value: Optional[pulumi.Input['DeliveryStreamBufferingHintsArgs']]):
        pulumi.set(self, "buffering_hints", value)

    @property
    @pulumi.getter(name="cloudWatchLoggingOptions")
    def cloud_watch_logging_options(self) -> Optional[pulumi.Input['DeliveryStreamCloudWatchLoggingOptionsArgs']]:
        return pulumi.get(self, "cloud_watch_logging_options")

    @cloud_watch_logging_options.setter
    def cloud_watch_logging_options(self, value: Optional[pulumi.Input['DeliveryStreamCloudWatchLoggingOptionsArgs']]):
        pulumi.set(self, "cloud_watch_logging_options", value)

    @property
    @pulumi.getter(name="processingConfiguration")
    def processing_configuration(self) -> Optional[pulumi.Input['DeliveryStreamProcessingConfigurationArgs']]:
        return pulumi.get(self, "processing_configuration")

    @processing_configuration.setter
    def processing_configuration(self, value: Optional[pulumi.Input['DeliveryStreamProcessingConfigurationArgs']]):
        pulumi.set(self, "processing_configuration", value)

    @property
    @pulumi.getter(name="requestConfiguration")
    def request_configuration(self) -> Optional[pulumi.Input['DeliveryStreamHttpEndpointRequestConfigurationArgs']]:
        return pulumi.get(self, "request_configuration")

    @request_configuration.setter
    def request_configuration(self, value: Optional[pulumi.Input['DeliveryStreamHttpEndpointRequestConfigurationArgs']]):
        pulumi.set(self, "request_configuration", value)

    @property
    @pulumi.getter(name="retryOptions")
    def retry_options(self) -> Optional[pulumi.Input['DeliveryStreamRetryOptionsArgs']]:
        return pulumi.get(self, "retry_options")

    @retry_options.setter
    def retry_options(self, value: Optional[pulumi.Input['DeliveryStreamRetryOptionsArgs']]):
        pulumi.set(self, "retry_options", value)

    @property
    @pulumi.getter(name="roleARN")
    def role_arn(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "role_arn")

    @role_arn.setter
    def role_arn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "role_arn", value)

    @property
    @pulumi.getter(name="s3BackupMode")
    def s3_backup_mode(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "s3_backup_mode")

    @s3_backup_mode.setter
    def s3_backup_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "s3_backup_mode", value)


@pulumi.input_type
class DeliveryStreamHttpEndpointRequestConfigurationArgs:
    def __init__(__self__, *,
                 common_attributes: Optional[pulumi.Input[Sequence[pulumi.Input['DeliveryStreamHttpEndpointCommonAttributeArgs']]]] = None,
                 content_encoding: Optional[pulumi.Input['DeliveryStreamHttpEndpointRequestConfigurationContentEncoding']] = None):
        if common_attributes is not None:
            pulumi.set(__self__, "common_attributes", common_attributes)
        if content_encoding is not None:
            pulumi.set(__self__, "content_encoding", content_encoding)

    @property
    @pulumi.getter(name="commonAttributes")
    def common_attributes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DeliveryStreamHttpEndpointCommonAttributeArgs']]]]:
        return pulumi.get(self, "common_attributes")

    @common_attributes.setter
    def common_attributes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DeliveryStreamHttpEndpointCommonAttributeArgs']]]]):
        pulumi.set(self, "common_attributes", value)

    @property
    @pulumi.getter(name="contentEncoding")
    def content_encoding(self) -> Optional[pulumi.Input['DeliveryStreamHttpEndpointRequestConfigurationContentEncoding']]:
        return pulumi.get(self, "content_encoding")

    @content_encoding.setter
    def content_encoding(self, value: Optional[pulumi.Input['DeliveryStreamHttpEndpointRequestConfigurationContentEncoding']]):
        pulumi.set(self, "content_encoding", value)


@pulumi.input_type
class DeliveryStreamInputFormatConfigurationArgs:
    def __init__(__self__, *,
                 deserializer: Optional[pulumi.Input['DeliveryStreamDeserializerArgs']] = None):
        if deserializer is not None:
            pulumi.set(__self__, "deserializer", deserializer)

    @property
    @pulumi.getter
    def deserializer(self) -> Optional[pulumi.Input['DeliveryStreamDeserializerArgs']]:
        return pulumi.get(self, "deserializer")

    @deserializer.setter
    def deserializer(self, value: Optional[pulumi.Input['DeliveryStreamDeserializerArgs']]):
        pulumi.set(self, "deserializer", value)


@pulumi.input_type
class DeliveryStreamKMSEncryptionConfigArgs:
    def __init__(__self__, *,
                 a_wskms_key_arn: pulumi.Input[str]):
        pulumi.set(__self__, "a_wskms_key_arn", a_wskms_key_arn)

    @property
    @pulumi.getter(name="aWSKMSKeyARN")
    def a_wskms_key_arn(self) -> pulumi.Input[str]:
        return pulumi.get(self, "a_wskms_key_arn")

    @a_wskms_key_arn.setter
    def a_wskms_key_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "a_wskms_key_arn", value)


@pulumi.input_type
class DeliveryStreamKinesisStreamSourceConfigurationArgs:
    def __init__(__self__, *,
                 kinesis_stream_arn: pulumi.Input[str],
                 role_arn: pulumi.Input[str]):
        pulumi.set(__self__, "kinesis_stream_arn", kinesis_stream_arn)
        pulumi.set(__self__, "role_arn", role_arn)

    @property
    @pulumi.getter(name="kinesisStreamARN")
    def kinesis_stream_arn(self) -> pulumi.Input[str]:
        return pulumi.get(self, "kinesis_stream_arn")

    @kinesis_stream_arn.setter
    def kinesis_stream_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "kinesis_stream_arn", value)

    @property
    @pulumi.getter(name="roleARN")
    def role_arn(self) -> pulumi.Input[str]:
        return pulumi.get(self, "role_arn")

    @role_arn.setter
    def role_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "role_arn", value)


@pulumi.input_type
class DeliveryStreamOpenXJsonSerDeArgs:
    def __init__(__self__, *,
                 case_insensitive: Optional[pulumi.Input[bool]] = None,
                 column_to_json_key_mappings: Optional[Any] = None,
                 convert_dots_in_json_keys_to_underscores: Optional[pulumi.Input[bool]] = None):
        if case_insensitive is not None:
            pulumi.set(__self__, "case_insensitive", case_insensitive)
        if column_to_json_key_mappings is not None:
            pulumi.set(__self__, "column_to_json_key_mappings", column_to_json_key_mappings)
        if convert_dots_in_json_keys_to_underscores is not None:
            pulumi.set(__self__, "convert_dots_in_json_keys_to_underscores", convert_dots_in_json_keys_to_underscores)

    @property
    @pulumi.getter(name="caseInsensitive")
    def case_insensitive(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "case_insensitive")

    @case_insensitive.setter
    def case_insensitive(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "case_insensitive", value)

    @property
    @pulumi.getter(name="columnToJsonKeyMappings")
    def column_to_json_key_mappings(self) -> Optional[Any]:
        return pulumi.get(self, "column_to_json_key_mappings")

    @column_to_json_key_mappings.setter
    def column_to_json_key_mappings(self, value: Optional[Any]):
        pulumi.set(self, "column_to_json_key_mappings", value)

    @property
    @pulumi.getter(name="convertDotsInJsonKeysToUnderscores")
    def convert_dots_in_json_keys_to_underscores(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "convert_dots_in_json_keys_to_underscores")

    @convert_dots_in_json_keys_to_underscores.setter
    def convert_dots_in_json_keys_to_underscores(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "convert_dots_in_json_keys_to_underscores", value)


@pulumi.input_type
class DeliveryStreamOrcSerDeArgs:
    def __init__(__self__, *,
                 block_size_bytes: Optional[pulumi.Input[int]] = None,
                 bloom_filter_columns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 bloom_filter_false_positive_probability: Optional[pulumi.Input[float]] = None,
                 compression: Optional[pulumi.Input[str]] = None,
                 dictionary_key_threshold: Optional[pulumi.Input[float]] = None,
                 enable_padding: Optional[pulumi.Input[bool]] = None,
                 format_version: Optional[pulumi.Input[str]] = None,
                 padding_tolerance: Optional[pulumi.Input[float]] = None,
                 row_index_stride: Optional[pulumi.Input[int]] = None,
                 stripe_size_bytes: Optional[pulumi.Input[int]] = None):
        if block_size_bytes is not None:
            pulumi.set(__self__, "block_size_bytes", block_size_bytes)
        if bloom_filter_columns is not None:
            pulumi.set(__self__, "bloom_filter_columns", bloom_filter_columns)
        if bloom_filter_false_positive_probability is not None:
            pulumi.set(__self__, "bloom_filter_false_positive_probability", bloom_filter_false_positive_probability)
        if compression is not None:
            pulumi.set(__self__, "compression", compression)
        if dictionary_key_threshold is not None:
            pulumi.set(__self__, "dictionary_key_threshold", dictionary_key_threshold)
        if enable_padding is not None:
            pulumi.set(__self__, "enable_padding", enable_padding)
        if format_version is not None:
            pulumi.set(__self__, "format_version", format_version)
        if padding_tolerance is not None:
            pulumi.set(__self__, "padding_tolerance", padding_tolerance)
        if row_index_stride is not None:
            pulumi.set(__self__, "row_index_stride", row_index_stride)
        if stripe_size_bytes is not None:
            pulumi.set(__self__, "stripe_size_bytes", stripe_size_bytes)

    @property
    @pulumi.getter(name="blockSizeBytes")
    def block_size_bytes(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "block_size_bytes")

    @block_size_bytes.setter
    def block_size_bytes(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "block_size_bytes", value)

    @property
    @pulumi.getter(name="bloomFilterColumns")
    def bloom_filter_columns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "bloom_filter_columns")

    @bloom_filter_columns.setter
    def bloom_filter_columns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "bloom_filter_columns", value)

    @property
    @pulumi.getter(name="bloomFilterFalsePositiveProbability")
    def bloom_filter_false_positive_probability(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "bloom_filter_false_positive_probability")

    @bloom_filter_false_positive_probability.setter
    def bloom_filter_false_positive_probability(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "bloom_filter_false_positive_probability", value)

    @property
    @pulumi.getter
    def compression(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "compression")

    @compression.setter
    def compression(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "compression", value)

    @property
    @pulumi.getter(name="dictionaryKeyThreshold")
    def dictionary_key_threshold(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "dictionary_key_threshold")

    @dictionary_key_threshold.setter
    def dictionary_key_threshold(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "dictionary_key_threshold", value)

    @property
    @pulumi.getter(name="enablePadding")
    def enable_padding(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "enable_padding")

    @enable_padding.setter
    def enable_padding(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_padding", value)

    @property
    @pulumi.getter(name="formatVersion")
    def format_version(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "format_version")

    @format_version.setter
    def format_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "format_version", value)

    @property
    @pulumi.getter(name="paddingTolerance")
    def padding_tolerance(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "padding_tolerance")

    @padding_tolerance.setter
    def padding_tolerance(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "padding_tolerance", value)

    @property
    @pulumi.getter(name="rowIndexStride")
    def row_index_stride(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "row_index_stride")

    @row_index_stride.setter
    def row_index_stride(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "row_index_stride", value)

    @property
    @pulumi.getter(name="stripeSizeBytes")
    def stripe_size_bytes(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "stripe_size_bytes")

    @stripe_size_bytes.setter
    def stripe_size_bytes(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "stripe_size_bytes", value)


@pulumi.input_type
class DeliveryStreamOutputFormatConfigurationArgs:
    def __init__(__self__, *,
                 serializer: Optional[pulumi.Input['DeliveryStreamSerializerArgs']] = None):
        if serializer is not None:
            pulumi.set(__self__, "serializer", serializer)

    @property
    @pulumi.getter
    def serializer(self) -> Optional[pulumi.Input['DeliveryStreamSerializerArgs']]:
        return pulumi.get(self, "serializer")

    @serializer.setter
    def serializer(self, value: Optional[pulumi.Input['DeliveryStreamSerializerArgs']]):
        pulumi.set(self, "serializer", value)


@pulumi.input_type
class DeliveryStreamParquetSerDeArgs:
    def __init__(__self__, *,
                 block_size_bytes: Optional[pulumi.Input[int]] = None,
                 compression: Optional[pulumi.Input[str]] = None,
                 enable_dictionary_compression: Optional[pulumi.Input[bool]] = None,
                 max_padding_bytes: Optional[pulumi.Input[int]] = None,
                 page_size_bytes: Optional[pulumi.Input[int]] = None,
                 writer_version: Optional[pulumi.Input[str]] = None):
        if block_size_bytes is not None:
            pulumi.set(__self__, "block_size_bytes", block_size_bytes)
        if compression is not None:
            pulumi.set(__self__, "compression", compression)
        if enable_dictionary_compression is not None:
            pulumi.set(__self__, "enable_dictionary_compression", enable_dictionary_compression)
        if max_padding_bytes is not None:
            pulumi.set(__self__, "max_padding_bytes", max_padding_bytes)
        if page_size_bytes is not None:
            pulumi.set(__self__, "page_size_bytes", page_size_bytes)
        if writer_version is not None:
            pulumi.set(__self__, "writer_version", writer_version)

    @property
    @pulumi.getter(name="blockSizeBytes")
    def block_size_bytes(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "block_size_bytes")

    @block_size_bytes.setter
    def block_size_bytes(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "block_size_bytes", value)

    @property
    @pulumi.getter
    def compression(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "compression")

    @compression.setter
    def compression(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "compression", value)

    @property
    @pulumi.getter(name="enableDictionaryCompression")
    def enable_dictionary_compression(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "enable_dictionary_compression")

    @enable_dictionary_compression.setter
    def enable_dictionary_compression(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_dictionary_compression", value)

    @property
    @pulumi.getter(name="maxPaddingBytes")
    def max_padding_bytes(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "max_padding_bytes")

    @max_padding_bytes.setter
    def max_padding_bytes(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_padding_bytes", value)

    @property
    @pulumi.getter(name="pageSizeBytes")
    def page_size_bytes(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "page_size_bytes")

    @page_size_bytes.setter
    def page_size_bytes(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "page_size_bytes", value)

    @property
    @pulumi.getter(name="writerVersion")
    def writer_version(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "writer_version")

    @writer_version.setter
    def writer_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "writer_version", value)


@pulumi.input_type
class DeliveryStreamProcessingConfigurationArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 processors: Optional[pulumi.Input[Sequence[pulumi.Input['DeliveryStreamProcessorArgs']]]] = None):
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if processors is not None:
            pulumi.set(__self__, "processors", processors)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter
    def processors(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DeliveryStreamProcessorArgs']]]]:
        return pulumi.get(self, "processors")

    @processors.setter
    def processors(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DeliveryStreamProcessorArgs']]]]):
        pulumi.set(self, "processors", value)


@pulumi.input_type
class DeliveryStreamProcessorParameterArgs:
    def __init__(__self__, *,
                 parameter_name: pulumi.Input[str],
                 parameter_value: pulumi.Input[str]):
        pulumi.set(__self__, "parameter_name", parameter_name)
        pulumi.set(__self__, "parameter_value", parameter_value)

    @property
    @pulumi.getter(name="parameterName")
    def parameter_name(self) -> pulumi.Input[str]:
        return pulumi.get(self, "parameter_name")

    @parameter_name.setter
    def parameter_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "parameter_name", value)

    @property
    @pulumi.getter(name="parameterValue")
    def parameter_value(self) -> pulumi.Input[str]:
        return pulumi.get(self, "parameter_value")

    @parameter_value.setter
    def parameter_value(self, value: pulumi.Input[str]):
        pulumi.set(self, "parameter_value", value)


@pulumi.input_type
class DeliveryStreamProcessorArgs:
    def __init__(__self__, *,
                 type: pulumi.Input['DeliveryStreamProcessorType'],
                 parameters: Optional[pulumi.Input[Sequence[pulumi.Input['DeliveryStreamProcessorParameterArgs']]]] = None):
        pulumi.set(__self__, "type", type)
        if parameters is not None:
            pulumi.set(__self__, "parameters", parameters)

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input['DeliveryStreamProcessorType']:
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: pulumi.Input['DeliveryStreamProcessorType']):
        pulumi.set(self, "type", value)

    @property
    @pulumi.getter
    def parameters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DeliveryStreamProcessorParameterArgs']]]]:
        return pulumi.get(self, "parameters")

    @parameters.setter
    def parameters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DeliveryStreamProcessorParameterArgs']]]]):
        pulumi.set(self, "parameters", value)


@pulumi.input_type
class DeliveryStreamRedshiftDestinationConfigurationArgs:
    def __init__(__self__, *,
                 cluster_jdbcurl: pulumi.Input[str],
                 copy_command: pulumi.Input['DeliveryStreamCopyCommandArgs'],
                 password: pulumi.Input[str],
                 role_arn: pulumi.Input[str],
                 s3_configuration: pulumi.Input['DeliveryStreamS3DestinationConfigurationArgs'],
                 username: pulumi.Input[str],
                 cloud_watch_logging_options: Optional[pulumi.Input['DeliveryStreamCloudWatchLoggingOptionsArgs']] = None,
                 processing_configuration: Optional[pulumi.Input['DeliveryStreamProcessingConfigurationArgs']] = None,
                 retry_options: Optional[pulumi.Input['DeliveryStreamRedshiftRetryOptionsArgs']] = None,
                 s3_backup_configuration: Optional[pulumi.Input['DeliveryStreamS3DestinationConfigurationArgs']] = None,
                 s3_backup_mode: Optional[pulumi.Input['DeliveryStreamRedshiftDestinationConfigurationS3BackupMode']] = None):
        pulumi.set(__self__, "cluster_jdbcurl", cluster_jdbcurl)
        pulumi.set(__self__, "copy_command", copy_command)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "role_arn", role_arn)
        pulumi.set(__self__, "s3_configuration", s3_configuration)
        pulumi.set(__self__, "username", username)
        if cloud_watch_logging_options is not None:
            pulumi.set(__self__, "cloud_watch_logging_options", cloud_watch_logging_options)
        if processing_configuration is not None:
            pulumi.set(__self__, "processing_configuration", processing_configuration)
        if retry_options is not None:
            pulumi.set(__self__, "retry_options", retry_options)
        if s3_backup_configuration is not None:
            pulumi.set(__self__, "s3_backup_configuration", s3_backup_configuration)
        if s3_backup_mode is not None:
            pulumi.set(__self__, "s3_backup_mode", s3_backup_mode)

    @property
    @pulumi.getter(name="clusterJDBCURL")
    def cluster_jdbcurl(self) -> pulumi.Input[str]:
        return pulumi.get(self, "cluster_jdbcurl")

    @cluster_jdbcurl.setter
    def cluster_jdbcurl(self, value: pulumi.Input[str]):
        pulumi.set(self, "cluster_jdbcurl", value)

    @property
    @pulumi.getter(name="copyCommand")
    def copy_command(self) -> pulumi.Input['DeliveryStreamCopyCommandArgs']:
        return pulumi.get(self, "copy_command")

    @copy_command.setter
    def copy_command(self, value: pulumi.Input['DeliveryStreamCopyCommandArgs']):
        pulumi.set(self, "copy_command", value)

    @property
    @pulumi.getter
    def password(self) -> pulumi.Input[str]:
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: pulumi.Input[str]):
        pulumi.set(self, "password", value)

    @property
    @pulumi.getter(name="roleARN")
    def role_arn(self) -> pulumi.Input[str]:
        return pulumi.get(self, "role_arn")

    @role_arn.setter
    def role_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "role_arn", value)

    @property
    @pulumi.getter(name="s3Configuration")
    def s3_configuration(self) -> pulumi.Input['DeliveryStreamS3DestinationConfigurationArgs']:
        return pulumi.get(self, "s3_configuration")

    @s3_configuration.setter
    def s3_configuration(self, value: pulumi.Input['DeliveryStreamS3DestinationConfigurationArgs']):
        pulumi.set(self, "s3_configuration", value)

    @property
    @pulumi.getter
    def username(self) -> pulumi.Input[str]:
        return pulumi.get(self, "username")

    @username.setter
    def username(self, value: pulumi.Input[str]):
        pulumi.set(self, "username", value)

    @property
    @pulumi.getter(name="cloudWatchLoggingOptions")
    def cloud_watch_logging_options(self) -> Optional[pulumi.Input['DeliveryStreamCloudWatchLoggingOptionsArgs']]:
        return pulumi.get(self, "cloud_watch_logging_options")

    @cloud_watch_logging_options.setter
    def cloud_watch_logging_options(self, value: Optional[pulumi.Input['DeliveryStreamCloudWatchLoggingOptionsArgs']]):
        pulumi.set(self, "cloud_watch_logging_options", value)

    @property
    @pulumi.getter(name="processingConfiguration")
    def processing_configuration(self) -> Optional[pulumi.Input['DeliveryStreamProcessingConfigurationArgs']]:
        return pulumi.get(self, "processing_configuration")

    @processing_configuration.setter
    def processing_configuration(self, value: Optional[pulumi.Input['DeliveryStreamProcessingConfigurationArgs']]):
        pulumi.set(self, "processing_configuration", value)

    @property
    @pulumi.getter(name="retryOptions")
    def retry_options(self) -> Optional[pulumi.Input['DeliveryStreamRedshiftRetryOptionsArgs']]:
        return pulumi.get(self, "retry_options")

    @retry_options.setter
    def retry_options(self, value: Optional[pulumi.Input['DeliveryStreamRedshiftRetryOptionsArgs']]):
        pulumi.set(self, "retry_options", value)

    @property
    @pulumi.getter(name="s3BackupConfiguration")
    def s3_backup_configuration(self) -> Optional[pulumi.Input['DeliveryStreamS3DestinationConfigurationArgs']]:
        return pulumi.get(self, "s3_backup_configuration")

    @s3_backup_configuration.setter
    def s3_backup_configuration(self, value: Optional[pulumi.Input['DeliveryStreamS3DestinationConfigurationArgs']]):
        pulumi.set(self, "s3_backup_configuration", value)

    @property
    @pulumi.getter(name="s3BackupMode")
    def s3_backup_mode(self) -> Optional[pulumi.Input['DeliveryStreamRedshiftDestinationConfigurationS3BackupMode']]:
        return pulumi.get(self, "s3_backup_mode")

    @s3_backup_mode.setter
    def s3_backup_mode(self, value: Optional[pulumi.Input['DeliveryStreamRedshiftDestinationConfigurationS3BackupMode']]):
        pulumi.set(self, "s3_backup_mode", value)


@pulumi.input_type
class DeliveryStreamRedshiftRetryOptionsArgs:
    def __init__(__self__, *,
                 duration_in_seconds: Optional[pulumi.Input[int]] = None):
        if duration_in_seconds is not None:
            pulumi.set(__self__, "duration_in_seconds", duration_in_seconds)

    @property
    @pulumi.getter(name="durationInSeconds")
    def duration_in_seconds(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "duration_in_seconds")

    @duration_in_seconds.setter
    def duration_in_seconds(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "duration_in_seconds", value)


@pulumi.input_type
class DeliveryStreamRetryOptionsArgs:
    def __init__(__self__, *,
                 duration_in_seconds: Optional[pulumi.Input[int]] = None):
        if duration_in_seconds is not None:
            pulumi.set(__self__, "duration_in_seconds", duration_in_seconds)

    @property
    @pulumi.getter(name="durationInSeconds")
    def duration_in_seconds(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "duration_in_seconds")

    @duration_in_seconds.setter
    def duration_in_seconds(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "duration_in_seconds", value)


@pulumi.input_type
class DeliveryStreamS3DestinationConfigurationArgs:
    def __init__(__self__, *,
                 bucket_arn: pulumi.Input[str],
                 role_arn: pulumi.Input[str],
                 buffering_hints: Optional[pulumi.Input['DeliveryStreamBufferingHintsArgs']] = None,
                 cloud_watch_logging_options: Optional[pulumi.Input['DeliveryStreamCloudWatchLoggingOptionsArgs']] = None,
                 compression_format: Optional[pulumi.Input['DeliveryStreamS3DestinationConfigurationCompressionFormat']] = None,
                 encryption_configuration: Optional[pulumi.Input['DeliveryStreamEncryptionConfigurationArgs']] = None,
                 error_output_prefix: Optional[pulumi.Input[str]] = None,
                 prefix: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "bucket_arn", bucket_arn)
        pulumi.set(__self__, "role_arn", role_arn)
        if buffering_hints is not None:
            pulumi.set(__self__, "buffering_hints", buffering_hints)
        if cloud_watch_logging_options is not None:
            pulumi.set(__self__, "cloud_watch_logging_options", cloud_watch_logging_options)
        if compression_format is not None:
            pulumi.set(__self__, "compression_format", compression_format)
        if encryption_configuration is not None:
            pulumi.set(__self__, "encryption_configuration", encryption_configuration)
        if error_output_prefix is not None:
            pulumi.set(__self__, "error_output_prefix", error_output_prefix)
        if prefix is not None:
            pulumi.set(__self__, "prefix", prefix)

    @property
    @pulumi.getter(name="bucketARN")
    def bucket_arn(self) -> pulumi.Input[str]:
        return pulumi.get(self, "bucket_arn")

    @bucket_arn.setter
    def bucket_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "bucket_arn", value)

    @property
    @pulumi.getter(name="roleARN")
    def role_arn(self) -> pulumi.Input[str]:
        return pulumi.get(self, "role_arn")

    @role_arn.setter
    def role_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "role_arn", value)

    @property
    @pulumi.getter(name="bufferingHints")
    def buffering_hints(self) -> Optional[pulumi.Input['DeliveryStreamBufferingHintsArgs']]:
        return pulumi.get(self, "buffering_hints")

    @buffering_hints.setter
    def buffering_hints(self, value: Optional[pulumi.Input['DeliveryStreamBufferingHintsArgs']]):
        pulumi.set(self, "buffering_hints", value)

    @property
    @pulumi.getter(name="cloudWatchLoggingOptions")
    def cloud_watch_logging_options(self) -> Optional[pulumi.Input['DeliveryStreamCloudWatchLoggingOptionsArgs']]:
        return pulumi.get(self, "cloud_watch_logging_options")

    @cloud_watch_logging_options.setter
    def cloud_watch_logging_options(self, value: Optional[pulumi.Input['DeliveryStreamCloudWatchLoggingOptionsArgs']]):
        pulumi.set(self, "cloud_watch_logging_options", value)

    @property
    @pulumi.getter(name="compressionFormat")
    def compression_format(self) -> Optional[pulumi.Input['DeliveryStreamS3DestinationConfigurationCompressionFormat']]:
        return pulumi.get(self, "compression_format")

    @compression_format.setter
    def compression_format(self, value: Optional[pulumi.Input['DeliveryStreamS3DestinationConfigurationCompressionFormat']]):
        pulumi.set(self, "compression_format", value)

    @property
    @pulumi.getter(name="encryptionConfiguration")
    def encryption_configuration(self) -> Optional[pulumi.Input['DeliveryStreamEncryptionConfigurationArgs']]:
        return pulumi.get(self, "encryption_configuration")

    @encryption_configuration.setter
    def encryption_configuration(self, value: Optional[pulumi.Input['DeliveryStreamEncryptionConfigurationArgs']]):
        pulumi.set(self, "encryption_configuration", value)

    @property
    @pulumi.getter(name="errorOutputPrefix")
    def error_output_prefix(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "error_output_prefix")

    @error_output_prefix.setter
    def error_output_prefix(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "error_output_prefix", value)

    @property
    @pulumi.getter
    def prefix(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "prefix")

    @prefix.setter
    def prefix(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "prefix", value)


@pulumi.input_type
class DeliveryStreamSchemaConfigurationArgs:
    def __init__(__self__, *,
                 catalog_id: Optional[pulumi.Input[str]] = None,
                 database_name: Optional[pulumi.Input[str]] = None,
                 region: Optional[pulumi.Input[str]] = None,
                 role_arn: Optional[pulumi.Input[str]] = None,
                 table_name: Optional[pulumi.Input[str]] = None,
                 version_id: Optional[pulumi.Input[str]] = None):
        if catalog_id is not None:
            pulumi.set(__self__, "catalog_id", catalog_id)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if role_arn is not None:
            pulumi.set(__self__, "role_arn", role_arn)
        if table_name is not None:
            pulumi.set(__self__, "table_name", table_name)
        if version_id is not None:
            pulumi.set(__self__, "version_id", version_id)

    @property
    @pulumi.getter(name="catalogId")
    def catalog_id(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "catalog_id")

    @catalog_id.setter
    def catalog_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "catalog_id", value)

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "database_name")

    @database_name.setter
    def database_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "database_name", value)

    @property
    @pulumi.getter
    def region(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "region")

    @region.setter
    def region(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "region", value)

    @property
    @pulumi.getter(name="roleARN")
    def role_arn(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "role_arn")

    @role_arn.setter
    def role_arn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "role_arn", value)

    @property
    @pulumi.getter(name="tableName")
    def table_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "table_name")

    @table_name.setter
    def table_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "table_name", value)

    @property
    @pulumi.getter(name="versionId")
    def version_id(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "version_id")

    @version_id.setter
    def version_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "version_id", value)


@pulumi.input_type
class DeliveryStreamSerializerArgs:
    def __init__(__self__, *,
                 orc_ser_de: Optional[pulumi.Input['DeliveryStreamOrcSerDeArgs']] = None,
                 parquet_ser_de: Optional[pulumi.Input['DeliveryStreamParquetSerDeArgs']] = None):
        if orc_ser_de is not None:
            pulumi.set(__self__, "orc_ser_de", orc_ser_de)
        if parquet_ser_de is not None:
            pulumi.set(__self__, "parquet_ser_de", parquet_ser_de)

    @property
    @pulumi.getter(name="orcSerDe")
    def orc_ser_de(self) -> Optional[pulumi.Input['DeliveryStreamOrcSerDeArgs']]:
        return pulumi.get(self, "orc_ser_de")

    @orc_ser_de.setter
    def orc_ser_de(self, value: Optional[pulumi.Input['DeliveryStreamOrcSerDeArgs']]):
        pulumi.set(self, "orc_ser_de", value)

    @property
    @pulumi.getter(name="parquetSerDe")
    def parquet_ser_de(self) -> Optional[pulumi.Input['DeliveryStreamParquetSerDeArgs']]:
        return pulumi.get(self, "parquet_ser_de")

    @parquet_ser_de.setter
    def parquet_ser_de(self, value: Optional[pulumi.Input['DeliveryStreamParquetSerDeArgs']]):
        pulumi.set(self, "parquet_ser_de", value)


@pulumi.input_type
class DeliveryStreamSplunkDestinationConfigurationArgs:
    def __init__(__self__, *,
                 h_ec_endpoint: pulumi.Input[str],
                 h_ec_endpoint_type: pulumi.Input['DeliveryStreamSplunkDestinationConfigurationHECEndpointType'],
                 h_ec_token: pulumi.Input[str],
                 s3_configuration: pulumi.Input['DeliveryStreamS3DestinationConfigurationArgs'],
                 cloud_watch_logging_options: Optional[pulumi.Input['DeliveryStreamCloudWatchLoggingOptionsArgs']] = None,
                 h_ec_acknowledgment_timeout_in_seconds: Optional[pulumi.Input[int]] = None,
                 processing_configuration: Optional[pulumi.Input['DeliveryStreamProcessingConfigurationArgs']] = None,
                 retry_options: Optional[pulumi.Input['DeliveryStreamSplunkRetryOptionsArgs']] = None,
                 s3_backup_mode: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "h_ec_endpoint", h_ec_endpoint)
        pulumi.set(__self__, "h_ec_endpoint_type", h_ec_endpoint_type)
        pulumi.set(__self__, "h_ec_token", h_ec_token)
        pulumi.set(__self__, "s3_configuration", s3_configuration)
        if cloud_watch_logging_options is not None:
            pulumi.set(__self__, "cloud_watch_logging_options", cloud_watch_logging_options)
        if h_ec_acknowledgment_timeout_in_seconds is not None:
            pulumi.set(__self__, "h_ec_acknowledgment_timeout_in_seconds", h_ec_acknowledgment_timeout_in_seconds)
        if processing_configuration is not None:
            pulumi.set(__self__, "processing_configuration", processing_configuration)
        if retry_options is not None:
            pulumi.set(__self__, "retry_options", retry_options)
        if s3_backup_mode is not None:
            pulumi.set(__self__, "s3_backup_mode", s3_backup_mode)

    @property
    @pulumi.getter(name="hECEndpoint")
    def h_ec_endpoint(self) -> pulumi.Input[str]:
        return pulumi.get(self, "h_ec_endpoint")

    @h_ec_endpoint.setter
    def h_ec_endpoint(self, value: pulumi.Input[str]):
        pulumi.set(self, "h_ec_endpoint", value)

    @property
    @pulumi.getter(name="hECEndpointType")
    def h_ec_endpoint_type(self) -> pulumi.Input['DeliveryStreamSplunkDestinationConfigurationHECEndpointType']:
        return pulumi.get(self, "h_ec_endpoint_type")

    @h_ec_endpoint_type.setter
    def h_ec_endpoint_type(self, value: pulumi.Input['DeliveryStreamSplunkDestinationConfigurationHECEndpointType']):
        pulumi.set(self, "h_ec_endpoint_type", value)

    @property
    @pulumi.getter(name="hECToken")
    def h_ec_token(self) -> pulumi.Input[str]:
        return pulumi.get(self, "h_ec_token")

    @h_ec_token.setter
    def h_ec_token(self, value: pulumi.Input[str]):
        pulumi.set(self, "h_ec_token", value)

    @property
    @pulumi.getter(name="s3Configuration")
    def s3_configuration(self) -> pulumi.Input['DeliveryStreamS3DestinationConfigurationArgs']:
        return pulumi.get(self, "s3_configuration")

    @s3_configuration.setter
    def s3_configuration(self, value: pulumi.Input['DeliveryStreamS3DestinationConfigurationArgs']):
        pulumi.set(self, "s3_configuration", value)

    @property
    @pulumi.getter(name="cloudWatchLoggingOptions")
    def cloud_watch_logging_options(self) -> Optional[pulumi.Input['DeliveryStreamCloudWatchLoggingOptionsArgs']]:
        return pulumi.get(self, "cloud_watch_logging_options")

    @cloud_watch_logging_options.setter
    def cloud_watch_logging_options(self, value: Optional[pulumi.Input['DeliveryStreamCloudWatchLoggingOptionsArgs']]):
        pulumi.set(self, "cloud_watch_logging_options", value)

    @property
    @pulumi.getter(name="hECAcknowledgmentTimeoutInSeconds")
    def h_ec_acknowledgment_timeout_in_seconds(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "h_ec_acknowledgment_timeout_in_seconds")

    @h_ec_acknowledgment_timeout_in_seconds.setter
    def h_ec_acknowledgment_timeout_in_seconds(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "h_ec_acknowledgment_timeout_in_seconds", value)

    @property
    @pulumi.getter(name="processingConfiguration")
    def processing_configuration(self) -> Optional[pulumi.Input['DeliveryStreamProcessingConfigurationArgs']]:
        return pulumi.get(self, "processing_configuration")

    @processing_configuration.setter
    def processing_configuration(self, value: Optional[pulumi.Input['DeliveryStreamProcessingConfigurationArgs']]):
        pulumi.set(self, "processing_configuration", value)

    @property
    @pulumi.getter(name="retryOptions")
    def retry_options(self) -> Optional[pulumi.Input['DeliveryStreamSplunkRetryOptionsArgs']]:
        return pulumi.get(self, "retry_options")

    @retry_options.setter
    def retry_options(self, value: Optional[pulumi.Input['DeliveryStreamSplunkRetryOptionsArgs']]):
        pulumi.set(self, "retry_options", value)

    @property
    @pulumi.getter(name="s3BackupMode")
    def s3_backup_mode(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "s3_backup_mode")

    @s3_backup_mode.setter
    def s3_backup_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "s3_backup_mode", value)


@pulumi.input_type
class DeliveryStreamSplunkRetryOptionsArgs:
    def __init__(__self__, *,
                 duration_in_seconds: Optional[pulumi.Input[int]] = None):
        if duration_in_seconds is not None:
            pulumi.set(__self__, "duration_in_seconds", duration_in_seconds)

    @property
    @pulumi.getter(name="durationInSeconds")
    def duration_in_seconds(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "duration_in_seconds")

    @duration_in_seconds.setter
    def duration_in_seconds(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "duration_in_seconds", value)


@pulumi.input_type
class DeliveryStreamTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class DeliveryStreamVpcConfigurationArgs:
    def __init__(__self__, *,
                 role_arn: pulumi.Input[str],
                 security_group_ids: pulumi.Input[Sequence[pulumi.Input[str]]],
                 subnet_ids: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(__self__, "role_arn", role_arn)
        pulumi.set(__self__, "security_group_ids", security_group_ids)
        pulumi.set(__self__, "subnet_ids", subnet_ids)

    @property
    @pulumi.getter(name="roleARN")
    def role_arn(self) -> pulumi.Input[str]:
        return pulumi.get(self, "role_arn")

    @role_arn.setter
    def role_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "role_arn", value)

    @property
    @pulumi.getter(name="securityGroupIds")
    def security_group_ids(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        return pulumi.get(self, "security_group_ids")

    @security_group_ids.setter
    def security_group_ids(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "security_group_ids", value)

    @property
    @pulumi.getter(name="subnetIds")
    def subnet_ids(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        return pulumi.get(self, "subnet_ids")

    @subnet_ids.setter
    def subnet_ids(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "subnet_ids", value)


