# 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 . import outputs
from ._enums import *

__all__ = [
    'DeliveryStreamBufferingHints',
    'DeliveryStreamCloudWatchLoggingOptions',
    'DeliveryStreamCopyCommand',
    'DeliveryStreamDataFormatConversionConfiguration',
    'DeliveryStreamDeliveryStreamEncryptionConfigurationInput',
    'DeliveryStreamDeserializer',
    'DeliveryStreamDynamicPartitioningConfiguration',
    'DeliveryStreamElasticsearchBufferingHints',
    'DeliveryStreamElasticsearchDestinationConfiguration',
    'DeliveryStreamElasticsearchRetryOptions',
    'DeliveryStreamEncryptionConfiguration',
    'DeliveryStreamExtendedS3DestinationConfiguration',
    'DeliveryStreamHiveJsonSerDe',
    'DeliveryStreamHttpEndpointCommonAttribute',
    'DeliveryStreamHttpEndpointConfiguration',
    'DeliveryStreamHttpEndpointDestinationConfiguration',
    'DeliveryStreamHttpEndpointRequestConfiguration',
    'DeliveryStreamInputFormatConfiguration',
    'DeliveryStreamKMSEncryptionConfig',
    'DeliveryStreamKinesisStreamSourceConfiguration',
    'DeliveryStreamOpenXJsonSerDe',
    'DeliveryStreamOrcSerDe',
    'DeliveryStreamOutputFormatConfiguration',
    'DeliveryStreamParquetSerDe',
    'DeliveryStreamProcessingConfiguration',
    'DeliveryStreamProcessor',
    'DeliveryStreamProcessorParameter',
    'DeliveryStreamRedshiftDestinationConfiguration',
    'DeliveryStreamRedshiftRetryOptions',
    'DeliveryStreamRetryOptions',
    'DeliveryStreamS3DestinationConfiguration',
    'DeliveryStreamSchemaConfiguration',
    'DeliveryStreamSerializer',
    'DeliveryStreamSplunkDestinationConfiguration',
    'DeliveryStreamSplunkRetryOptions',
    'DeliveryStreamTag',
    'DeliveryStreamVpcConfiguration',
]

@pulumi.output_type
class DeliveryStreamBufferingHints(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "intervalInSeconds":
            suggest = "interval_in_seconds"
        elif key == "sizeInMBs":
            suggest = "size_in_mbs"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DeliveryStreamBufferingHints. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DeliveryStreamBufferingHints.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DeliveryStreamBufferingHints.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 interval_in_seconds: Optional[int] = None,
                 size_in_mbs: Optional[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[int]:
        return pulumi.get(self, "interval_in_seconds")

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


@pulumi.output_type
class DeliveryStreamCloudWatchLoggingOptions(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "logGroupName":
            suggest = "log_group_name"
        elif key == "logStreamName":
            suggest = "log_stream_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DeliveryStreamCloudWatchLoggingOptions. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DeliveryStreamCloudWatchLoggingOptions.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DeliveryStreamCloudWatchLoggingOptions.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 enabled: Optional[bool] = None,
                 log_group_name: Optional[str] = None,
                 log_stream_name: Optional[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[bool]:
        return pulumi.get(self, "enabled")

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

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


@pulumi.output_type
class DeliveryStreamCopyCommand(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "dataTableName":
            suggest = "data_table_name"
        elif key == "copyOptions":
            suggest = "copy_options"
        elif key == "dataTableColumns":
            suggest = "data_table_columns"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DeliveryStreamCopyCommand. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DeliveryStreamCopyCommand.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DeliveryStreamCopyCommand.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 data_table_name: str,
                 copy_options: Optional[str] = None,
                 data_table_columns: Optional[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) -> str:
        return pulumi.get(self, "data_table_name")

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

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


@pulumi.output_type
class DeliveryStreamDataFormatConversionConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "inputFormatConfiguration":
            suggest = "input_format_configuration"
        elif key == "outputFormatConfiguration":
            suggest = "output_format_configuration"
        elif key == "schemaConfiguration":
            suggest = "schema_configuration"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DeliveryStreamDataFormatConversionConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DeliveryStreamDataFormatConversionConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DeliveryStreamDataFormatConversionConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 enabled: Optional[bool] = None,
                 input_format_configuration: Optional['outputs.DeliveryStreamInputFormatConfiguration'] = None,
                 output_format_configuration: Optional['outputs.DeliveryStreamOutputFormatConfiguration'] = None,
                 schema_configuration: Optional['outputs.DeliveryStreamSchemaConfiguration'] = 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[bool]:
        return pulumi.get(self, "enabled")

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

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

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


@pulumi.output_type
class DeliveryStreamDeliveryStreamEncryptionConfigurationInput(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "keyType":
            suggest = "key_type"
        elif key == "keyARN":
            suggest = "key_arn"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DeliveryStreamDeliveryStreamEncryptionConfigurationInput. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DeliveryStreamDeliveryStreamEncryptionConfigurationInput.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DeliveryStreamDeliveryStreamEncryptionConfigurationInput.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 key_type: 'DeliveryStreamDeliveryStreamEncryptionConfigurationInputKeyType',
                 key_arn: Optional[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) -> 'DeliveryStreamDeliveryStreamEncryptionConfigurationInputKeyType':
        return pulumi.get(self, "key_type")

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


@pulumi.output_type
class DeliveryStreamDeserializer(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "hiveJsonSerDe":
            suggest = "hive_json_ser_de"
        elif key == "openXJsonSerDe":
            suggest = "open_x_json_ser_de"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DeliveryStreamDeserializer. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DeliveryStreamDeserializer.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DeliveryStreamDeserializer.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 hive_json_ser_de: Optional['outputs.DeliveryStreamHiveJsonSerDe'] = None,
                 open_x_json_ser_de: Optional['outputs.DeliveryStreamOpenXJsonSerDe'] = 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['outputs.DeliveryStreamHiveJsonSerDe']:
        return pulumi.get(self, "hive_json_ser_de")

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


@pulumi.output_type
class DeliveryStreamDynamicPartitioningConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "retryOptions":
            suggest = "retry_options"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DeliveryStreamDynamicPartitioningConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DeliveryStreamDynamicPartitioningConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DeliveryStreamDynamicPartitioningConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 enabled: Optional[bool] = None,
                 retry_options: Optional['outputs.DeliveryStreamRetryOptions'] = 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[bool]:
        return pulumi.get(self, "enabled")

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


@pulumi.output_type
class DeliveryStreamElasticsearchBufferingHints(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "intervalInSeconds":
            suggest = "interval_in_seconds"
        elif key == "sizeInMBs":
            suggest = "size_in_mbs"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DeliveryStreamElasticsearchBufferingHints. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DeliveryStreamElasticsearchBufferingHints.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DeliveryStreamElasticsearchBufferingHints.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 interval_in_seconds: Optional[int] = None,
                 size_in_mbs: Optional[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[int]:
        return pulumi.get(self, "interval_in_seconds")

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


@pulumi.output_type
class DeliveryStreamElasticsearchDestinationConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "indexName":
            suggest = "index_name"
        elif key == "roleARN":
            suggest = "role_arn"
        elif key == "s3Configuration":
            suggest = "s3_configuration"
        elif key == "bufferingHints":
            suggest = "buffering_hints"
        elif key == "cloudWatchLoggingOptions":
            suggest = "cloud_watch_logging_options"
        elif key == "clusterEndpoint":
            suggest = "cluster_endpoint"
        elif key == "domainARN":
            suggest = "domain_arn"
        elif key == "indexRotationPeriod":
            suggest = "index_rotation_period"
        elif key == "processingConfiguration":
            suggest = "processing_configuration"
        elif key == "retryOptions":
            suggest = "retry_options"
        elif key == "s3BackupMode":
            suggest = "s3_backup_mode"
        elif key == "typeName":
            suggest = "type_name"
        elif key == "vpcConfiguration":
            suggest = "vpc_configuration"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DeliveryStreamElasticsearchDestinationConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DeliveryStreamElasticsearchDestinationConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DeliveryStreamElasticsearchDestinationConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 index_name: str,
                 role_arn: str,
                 s3_configuration: 'outputs.DeliveryStreamS3DestinationConfiguration',
                 buffering_hints: Optional['outputs.DeliveryStreamElasticsearchBufferingHints'] = None,
                 cloud_watch_logging_options: Optional['outputs.DeliveryStreamCloudWatchLoggingOptions'] = None,
                 cluster_endpoint: Optional[str] = None,
                 domain_arn: Optional[str] = None,
                 index_rotation_period: Optional['DeliveryStreamElasticsearchDestinationConfigurationIndexRotationPeriod'] = None,
                 processing_configuration: Optional['outputs.DeliveryStreamProcessingConfiguration'] = None,
                 retry_options: Optional['outputs.DeliveryStreamElasticsearchRetryOptions'] = None,
                 s3_backup_mode: Optional['DeliveryStreamElasticsearchDestinationConfigurationS3BackupMode'] = None,
                 type_name: Optional[str] = None,
                 vpc_configuration: Optional['outputs.DeliveryStreamVpcConfiguration'] = 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) -> str:
        return pulumi.get(self, "index_name")

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

    @property
    @pulumi.getter(name="s3Configuration")
    def s3_configuration(self) -> 'outputs.DeliveryStreamS3DestinationConfiguration':
        return pulumi.get(self, "s3_configuration")

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

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

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

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

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

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

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

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

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

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


@pulumi.output_type
class DeliveryStreamElasticsearchRetryOptions(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "durationInSeconds":
            suggest = "duration_in_seconds"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DeliveryStreamElasticsearchRetryOptions. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DeliveryStreamElasticsearchRetryOptions.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DeliveryStreamElasticsearchRetryOptions.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 duration_in_seconds: Optional[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[int]:
        return pulumi.get(self, "duration_in_seconds")


@pulumi.output_type
class DeliveryStreamEncryptionConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "kMSEncryptionConfig":
            suggest = "k_ms_encryption_config"
        elif key == "noEncryptionConfig":
            suggest = "no_encryption_config"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DeliveryStreamEncryptionConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DeliveryStreamEncryptionConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DeliveryStreamEncryptionConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 k_ms_encryption_config: Optional['outputs.DeliveryStreamKMSEncryptionConfig'] = None,
                 no_encryption_config: Optional['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['outputs.DeliveryStreamKMSEncryptionConfig']:
        return pulumi.get(self, "k_ms_encryption_config")

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


@pulumi.output_type
class DeliveryStreamExtendedS3DestinationConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bucketARN":
            suggest = "bucket_arn"
        elif key == "roleARN":
            suggest = "role_arn"
        elif key == "bufferingHints":
            suggest = "buffering_hints"
        elif key == "cloudWatchLoggingOptions":
            suggest = "cloud_watch_logging_options"
        elif key == "compressionFormat":
            suggest = "compression_format"
        elif key == "dataFormatConversionConfiguration":
            suggest = "data_format_conversion_configuration"
        elif key == "dynamicPartitioningConfiguration":
            suggest = "dynamic_partitioning_configuration"
        elif key == "encryptionConfiguration":
            suggest = "encryption_configuration"
        elif key == "errorOutputPrefix":
            suggest = "error_output_prefix"
        elif key == "processingConfiguration":
            suggest = "processing_configuration"
        elif key == "s3BackupConfiguration":
            suggest = "s3_backup_configuration"
        elif key == "s3BackupMode":
            suggest = "s3_backup_mode"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DeliveryStreamExtendedS3DestinationConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DeliveryStreamExtendedS3DestinationConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DeliveryStreamExtendedS3DestinationConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 bucket_arn: str,
                 role_arn: str,
                 buffering_hints: Optional['outputs.DeliveryStreamBufferingHints'] = None,
                 cloud_watch_logging_options: Optional['outputs.DeliveryStreamCloudWatchLoggingOptions'] = None,
                 compression_format: Optional['DeliveryStreamExtendedS3DestinationConfigurationCompressionFormat'] = None,
                 data_format_conversion_configuration: Optional['outputs.DeliveryStreamDataFormatConversionConfiguration'] = None,
                 dynamic_partitioning_configuration: Optional['outputs.DeliveryStreamDynamicPartitioningConfiguration'] = None,
                 encryption_configuration: Optional['outputs.DeliveryStreamEncryptionConfiguration'] = None,
                 error_output_prefix: Optional[str] = None,
                 prefix: Optional[str] = None,
                 processing_configuration: Optional['outputs.DeliveryStreamProcessingConfiguration'] = None,
                 s3_backup_configuration: Optional['outputs.DeliveryStreamS3DestinationConfiguration'] = None,
                 s3_backup_mode: Optional['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) -> str:
        return pulumi.get(self, "bucket_arn")

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.output_type
class DeliveryStreamHiveJsonSerDe(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "timestampFormats":
            suggest = "timestamp_formats"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DeliveryStreamHiveJsonSerDe. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DeliveryStreamHiveJsonSerDe.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DeliveryStreamHiveJsonSerDe.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 timestamp_formats: Optional[Sequence[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[Sequence[str]]:
        return pulumi.get(self, "timestamp_formats")


@pulumi.output_type
class DeliveryStreamHttpEndpointCommonAttribute(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "attributeName":
            suggest = "attribute_name"
        elif key == "attributeValue":
            suggest = "attribute_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DeliveryStreamHttpEndpointCommonAttribute. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DeliveryStreamHttpEndpointCommonAttribute.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DeliveryStreamHttpEndpointCommonAttribute.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 attribute_name: str,
                 attribute_value: str):
        pulumi.set(__self__, "attribute_name", attribute_name)
        pulumi.set(__self__, "attribute_value", attribute_value)

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

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


@pulumi.output_type
class DeliveryStreamHttpEndpointConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessKey":
            suggest = "access_key"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DeliveryStreamHttpEndpointConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DeliveryStreamHttpEndpointConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DeliveryStreamHttpEndpointConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 url: str,
                 access_key: Optional[str] = None,
                 name: Optional[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) -> str:
        return pulumi.get(self, "url")

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

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


@pulumi.output_type
class DeliveryStreamHttpEndpointDestinationConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "endpointConfiguration":
            suggest = "endpoint_configuration"
        elif key == "s3Configuration":
            suggest = "s3_configuration"
        elif key == "bufferingHints":
            suggest = "buffering_hints"
        elif key == "cloudWatchLoggingOptions":
            suggest = "cloud_watch_logging_options"
        elif key == "processingConfiguration":
            suggest = "processing_configuration"
        elif key == "requestConfiguration":
            suggest = "request_configuration"
        elif key == "retryOptions":
            suggest = "retry_options"
        elif key == "roleARN":
            suggest = "role_arn"
        elif key == "s3BackupMode":
            suggest = "s3_backup_mode"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DeliveryStreamHttpEndpointDestinationConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DeliveryStreamHttpEndpointDestinationConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DeliveryStreamHttpEndpointDestinationConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 endpoint_configuration: 'outputs.DeliveryStreamHttpEndpointConfiguration',
                 s3_configuration: 'outputs.DeliveryStreamS3DestinationConfiguration',
                 buffering_hints: Optional['outputs.DeliveryStreamBufferingHints'] = None,
                 cloud_watch_logging_options: Optional['outputs.DeliveryStreamCloudWatchLoggingOptions'] = None,
                 processing_configuration: Optional['outputs.DeliveryStreamProcessingConfiguration'] = None,
                 request_configuration: Optional['outputs.DeliveryStreamHttpEndpointRequestConfiguration'] = None,
                 retry_options: Optional['outputs.DeliveryStreamRetryOptions'] = None,
                 role_arn: Optional[str] = None,
                 s3_backup_mode: Optional[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) -> 'outputs.DeliveryStreamHttpEndpointConfiguration':
        return pulumi.get(self, "endpoint_configuration")

    @property
    @pulumi.getter(name="s3Configuration")
    def s3_configuration(self) -> 'outputs.DeliveryStreamS3DestinationConfiguration':
        return pulumi.get(self, "s3_configuration")

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

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

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

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

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

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

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


@pulumi.output_type
class DeliveryStreamHttpEndpointRequestConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "commonAttributes":
            suggest = "common_attributes"
        elif key == "contentEncoding":
            suggest = "content_encoding"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DeliveryStreamHttpEndpointRequestConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DeliveryStreamHttpEndpointRequestConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DeliveryStreamHttpEndpointRequestConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 common_attributes: Optional[Sequence['outputs.DeliveryStreamHttpEndpointCommonAttribute']] = None,
                 content_encoding: Optional['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[Sequence['outputs.DeliveryStreamHttpEndpointCommonAttribute']]:
        return pulumi.get(self, "common_attributes")

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


@pulumi.output_type
class DeliveryStreamInputFormatConfiguration(dict):
    def __init__(__self__, *,
                 deserializer: Optional['outputs.DeliveryStreamDeserializer'] = None):
        if deserializer is not None:
            pulumi.set(__self__, "deserializer", deserializer)

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


@pulumi.output_type
class DeliveryStreamKMSEncryptionConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "aWSKMSKeyARN":
            suggest = "a_wskms_key_arn"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DeliveryStreamKMSEncryptionConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DeliveryStreamKMSEncryptionConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DeliveryStreamKMSEncryptionConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 a_wskms_key_arn: str):
        pulumi.set(__self__, "a_wskms_key_arn", a_wskms_key_arn)

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


@pulumi.output_type
class DeliveryStreamKinesisStreamSourceConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "kinesisStreamARN":
            suggest = "kinesis_stream_arn"
        elif key == "roleARN":
            suggest = "role_arn"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DeliveryStreamKinesisStreamSourceConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DeliveryStreamKinesisStreamSourceConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DeliveryStreamKinesisStreamSourceConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 kinesis_stream_arn: str,
                 role_arn: 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) -> str:
        return pulumi.get(self, "kinesis_stream_arn")

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


@pulumi.output_type
class DeliveryStreamOpenXJsonSerDe(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "caseInsensitive":
            suggest = "case_insensitive"
        elif key == "columnToJsonKeyMappings":
            suggest = "column_to_json_key_mappings"
        elif key == "convertDotsInJsonKeysToUnderscores":
            suggest = "convert_dots_in_json_keys_to_underscores"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DeliveryStreamOpenXJsonSerDe. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DeliveryStreamOpenXJsonSerDe.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DeliveryStreamOpenXJsonSerDe.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 case_insensitive: Optional[bool] = None,
                 column_to_json_key_mappings: Optional[Any] = None,
                 convert_dots_in_json_keys_to_underscores: Optional[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[bool]:
        return pulumi.get(self, "case_insensitive")

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

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


@pulumi.output_type
class DeliveryStreamOrcSerDe(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "blockSizeBytes":
            suggest = "block_size_bytes"
        elif key == "bloomFilterColumns":
            suggest = "bloom_filter_columns"
        elif key == "bloomFilterFalsePositiveProbability":
            suggest = "bloom_filter_false_positive_probability"
        elif key == "dictionaryKeyThreshold":
            suggest = "dictionary_key_threshold"
        elif key == "enablePadding":
            suggest = "enable_padding"
        elif key == "formatVersion":
            suggest = "format_version"
        elif key == "paddingTolerance":
            suggest = "padding_tolerance"
        elif key == "rowIndexStride":
            suggest = "row_index_stride"
        elif key == "stripeSizeBytes":
            suggest = "stripe_size_bytes"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DeliveryStreamOrcSerDe. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DeliveryStreamOrcSerDe.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DeliveryStreamOrcSerDe.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 block_size_bytes: Optional[int] = None,
                 bloom_filter_columns: Optional[Sequence[str]] = None,
                 bloom_filter_false_positive_probability: Optional[float] = None,
                 compression: Optional[str] = None,
                 dictionary_key_threshold: Optional[float] = None,
                 enable_padding: Optional[bool] = None,
                 format_version: Optional[str] = None,
                 padding_tolerance: Optional[float] = None,
                 row_index_stride: Optional[int] = None,
                 stripe_size_bytes: Optional[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[int]:
        return pulumi.get(self, "block_size_bytes")

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

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

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

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

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

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

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

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

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


@pulumi.output_type
class DeliveryStreamOutputFormatConfiguration(dict):
    def __init__(__self__, *,
                 serializer: Optional['outputs.DeliveryStreamSerializer'] = None):
        if serializer is not None:
            pulumi.set(__self__, "serializer", serializer)

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


@pulumi.output_type
class DeliveryStreamParquetSerDe(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "blockSizeBytes":
            suggest = "block_size_bytes"
        elif key == "enableDictionaryCompression":
            suggest = "enable_dictionary_compression"
        elif key == "maxPaddingBytes":
            suggest = "max_padding_bytes"
        elif key == "pageSizeBytes":
            suggest = "page_size_bytes"
        elif key == "writerVersion":
            suggest = "writer_version"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DeliveryStreamParquetSerDe. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DeliveryStreamParquetSerDe.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DeliveryStreamParquetSerDe.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 block_size_bytes: Optional[int] = None,
                 compression: Optional[str] = None,
                 enable_dictionary_compression: Optional[bool] = None,
                 max_padding_bytes: Optional[int] = None,
                 page_size_bytes: Optional[int] = None,
                 writer_version: Optional[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[int]:
        return pulumi.get(self, "block_size_bytes")

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

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

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

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

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


@pulumi.output_type
class DeliveryStreamProcessingConfiguration(dict):
    def __init__(__self__, *,
                 enabled: Optional[bool] = None,
                 processors: Optional[Sequence['outputs.DeliveryStreamProcessor']] = 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[bool]:
        return pulumi.get(self, "enabled")

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


@pulumi.output_type
class DeliveryStreamProcessor(dict):
    def __init__(__self__, *,
                 type: 'DeliveryStreamProcessorType',
                 parameters: Optional[Sequence['outputs.DeliveryStreamProcessorParameter']] = None):
        pulumi.set(__self__, "type", type)
        if parameters is not None:
            pulumi.set(__self__, "parameters", parameters)

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

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


@pulumi.output_type
class DeliveryStreamProcessorParameter(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "parameterName":
            suggest = "parameter_name"
        elif key == "parameterValue":
            suggest = "parameter_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DeliveryStreamProcessorParameter. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DeliveryStreamProcessorParameter.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DeliveryStreamProcessorParameter.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 parameter_name: str,
                 parameter_value: str):
        pulumi.set(__self__, "parameter_name", parameter_name)
        pulumi.set(__self__, "parameter_value", parameter_value)

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

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


@pulumi.output_type
class DeliveryStreamRedshiftDestinationConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clusterJDBCURL":
            suggest = "cluster_jdbcurl"
        elif key == "copyCommand":
            suggest = "copy_command"
        elif key == "roleARN":
            suggest = "role_arn"
        elif key == "s3Configuration":
            suggest = "s3_configuration"
        elif key == "cloudWatchLoggingOptions":
            suggest = "cloud_watch_logging_options"
        elif key == "processingConfiguration":
            suggest = "processing_configuration"
        elif key == "retryOptions":
            suggest = "retry_options"
        elif key == "s3BackupConfiguration":
            suggest = "s3_backup_configuration"
        elif key == "s3BackupMode":
            suggest = "s3_backup_mode"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DeliveryStreamRedshiftDestinationConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DeliveryStreamRedshiftDestinationConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DeliveryStreamRedshiftDestinationConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cluster_jdbcurl: str,
                 copy_command: 'outputs.DeliveryStreamCopyCommand',
                 password: str,
                 role_arn: str,
                 s3_configuration: 'outputs.DeliveryStreamS3DestinationConfiguration',
                 username: str,
                 cloud_watch_logging_options: Optional['outputs.DeliveryStreamCloudWatchLoggingOptions'] = None,
                 processing_configuration: Optional['outputs.DeliveryStreamProcessingConfiguration'] = None,
                 retry_options: Optional['outputs.DeliveryStreamRedshiftRetryOptions'] = None,
                 s3_backup_configuration: Optional['outputs.DeliveryStreamS3DestinationConfiguration'] = None,
                 s3_backup_mode: Optional['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) -> str:
        return pulumi.get(self, "cluster_jdbcurl")

    @property
    @pulumi.getter(name="copyCommand")
    def copy_command(self) -> 'outputs.DeliveryStreamCopyCommand':
        return pulumi.get(self, "copy_command")

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

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

    @property
    @pulumi.getter(name="s3Configuration")
    def s3_configuration(self) -> 'outputs.DeliveryStreamS3DestinationConfiguration':
        return pulumi.get(self, "s3_configuration")

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

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

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

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

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

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


@pulumi.output_type
class DeliveryStreamRedshiftRetryOptions(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "durationInSeconds":
            suggest = "duration_in_seconds"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DeliveryStreamRedshiftRetryOptions. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DeliveryStreamRedshiftRetryOptions.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DeliveryStreamRedshiftRetryOptions.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 duration_in_seconds: Optional[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[int]:
        return pulumi.get(self, "duration_in_seconds")


@pulumi.output_type
class DeliveryStreamRetryOptions(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "durationInSeconds":
            suggest = "duration_in_seconds"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DeliveryStreamRetryOptions. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DeliveryStreamRetryOptions.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DeliveryStreamRetryOptions.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 duration_in_seconds: Optional[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[int]:
        return pulumi.get(self, "duration_in_seconds")


@pulumi.output_type
class DeliveryStreamS3DestinationConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bucketARN":
            suggest = "bucket_arn"
        elif key == "roleARN":
            suggest = "role_arn"
        elif key == "bufferingHints":
            suggest = "buffering_hints"
        elif key == "cloudWatchLoggingOptions":
            suggest = "cloud_watch_logging_options"
        elif key == "compressionFormat":
            suggest = "compression_format"
        elif key == "encryptionConfiguration":
            suggest = "encryption_configuration"
        elif key == "errorOutputPrefix":
            suggest = "error_output_prefix"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DeliveryStreamS3DestinationConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DeliveryStreamS3DestinationConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DeliveryStreamS3DestinationConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 bucket_arn: str,
                 role_arn: str,
                 buffering_hints: Optional['outputs.DeliveryStreamBufferingHints'] = None,
                 cloud_watch_logging_options: Optional['outputs.DeliveryStreamCloudWatchLoggingOptions'] = None,
                 compression_format: Optional['DeliveryStreamS3DestinationConfigurationCompressionFormat'] = None,
                 encryption_configuration: Optional['outputs.DeliveryStreamEncryptionConfiguration'] = None,
                 error_output_prefix: Optional[str] = None,
                 prefix: Optional[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) -> str:
        return pulumi.get(self, "bucket_arn")

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

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

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

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

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

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

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


@pulumi.output_type
class DeliveryStreamSchemaConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "catalogId":
            suggest = "catalog_id"
        elif key == "databaseName":
            suggest = "database_name"
        elif key == "roleARN":
            suggest = "role_arn"
        elif key == "tableName":
            suggest = "table_name"
        elif key == "versionId":
            suggest = "version_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DeliveryStreamSchemaConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DeliveryStreamSchemaConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DeliveryStreamSchemaConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 catalog_id: Optional[str] = None,
                 database_name: Optional[str] = None,
                 region: Optional[str] = None,
                 role_arn: Optional[str] = None,
                 table_name: Optional[str] = None,
                 version_id: Optional[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[str]:
        return pulumi.get(self, "catalog_id")

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

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

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

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

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


@pulumi.output_type
class DeliveryStreamSerializer(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "orcSerDe":
            suggest = "orc_ser_de"
        elif key == "parquetSerDe":
            suggest = "parquet_ser_de"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DeliveryStreamSerializer. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DeliveryStreamSerializer.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DeliveryStreamSerializer.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 orc_ser_de: Optional['outputs.DeliveryStreamOrcSerDe'] = None,
                 parquet_ser_de: Optional['outputs.DeliveryStreamParquetSerDe'] = 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['outputs.DeliveryStreamOrcSerDe']:
        return pulumi.get(self, "orc_ser_de")

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


@pulumi.output_type
class DeliveryStreamSplunkDestinationConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "hECEndpoint":
            suggest = "h_ec_endpoint"
        elif key == "hECEndpointType":
            suggest = "h_ec_endpoint_type"
        elif key == "hECToken":
            suggest = "h_ec_token"
        elif key == "s3Configuration":
            suggest = "s3_configuration"
        elif key == "cloudWatchLoggingOptions":
            suggest = "cloud_watch_logging_options"
        elif key == "hECAcknowledgmentTimeoutInSeconds":
            suggest = "h_ec_acknowledgment_timeout_in_seconds"
        elif key == "processingConfiguration":
            suggest = "processing_configuration"
        elif key == "retryOptions":
            suggest = "retry_options"
        elif key == "s3BackupMode":
            suggest = "s3_backup_mode"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DeliveryStreamSplunkDestinationConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DeliveryStreamSplunkDestinationConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DeliveryStreamSplunkDestinationConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 h_ec_endpoint: str,
                 h_ec_endpoint_type: 'DeliveryStreamSplunkDestinationConfigurationHECEndpointType',
                 h_ec_token: str,
                 s3_configuration: 'outputs.DeliveryStreamS3DestinationConfiguration',
                 cloud_watch_logging_options: Optional['outputs.DeliveryStreamCloudWatchLoggingOptions'] = None,
                 h_ec_acknowledgment_timeout_in_seconds: Optional[int] = None,
                 processing_configuration: Optional['outputs.DeliveryStreamProcessingConfiguration'] = None,
                 retry_options: Optional['outputs.DeliveryStreamSplunkRetryOptions'] = None,
                 s3_backup_mode: Optional[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) -> str:
        return pulumi.get(self, "h_ec_endpoint")

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

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

    @property
    @pulumi.getter(name="s3Configuration")
    def s3_configuration(self) -> 'outputs.DeliveryStreamS3DestinationConfiguration':
        return pulumi.get(self, "s3_configuration")

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

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

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

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

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


@pulumi.output_type
class DeliveryStreamSplunkRetryOptions(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "durationInSeconds":
            suggest = "duration_in_seconds"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DeliveryStreamSplunkRetryOptions. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DeliveryStreamSplunkRetryOptions.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DeliveryStreamSplunkRetryOptions.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 duration_in_seconds: Optional[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[int]:
        return pulumi.get(self, "duration_in_seconds")


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

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

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


@pulumi.output_type
class DeliveryStreamVpcConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "roleARN":
            suggest = "role_arn"
        elif key == "securityGroupIds":
            suggest = "security_group_ids"
        elif key == "subnetIds":
            suggest = "subnet_ids"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DeliveryStreamVpcConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DeliveryStreamVpcConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DeliveryStreamVpcConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 role_arn: str,
                 security_group_ids: Sequence[str],
                 subnet_ids: Sequence[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) -> str:
        return pulumi.get(self, "role_arn")

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

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


