# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** 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
from .. import _utilities, _tables
from . import outputs

__all__ = [
    'ApplicationApplicationConfiguration',
    'ApplicationApplicationConfigurationApplicationCodeConfiguration',
    'ApplicationApplicationConfigurationApplicationCodeConfigurationCodeContent',
    'ApplicationApplicationConfigurationApplicationCodeConfigurationCodeContentS3ContentLocation',
    'ApplicationApplicationConfigurationApplicationSnapshotConfiguration',
    'ApplicationApplicationConfigurationEnvironmentProperties',
    'ApplicationApplicationConfigurationEnvironmentPropertiesPropertyGroup',
    'ApplicationApplicationConfigurationFlinkApplicationConfiguration',
    'ApplicationApplicationConfigurationFlinkApplicationConfigurationCheckpointConfiguration',
    'ApplicationApplicationConfigurationFlinkApplicationConfigurationMonitoringConfiguration',
    'ApplicationApplicationConfigurationFlinkApplicationConfigurationParallelismConfiguration',
    'ApplicationApplicationConfigurationSqlApplicationConfiguration',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationInput',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputParallelism',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputProcessingConfiguration',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputProcessingConfigurationInputLambdaProcessor',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchema',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordColumn',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordFormat',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordFormatMappingParameters',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordFormatMappingParametersCsvMappingParameters',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordFormatMappingParametersJsonMappingParameters',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputStartingPositionConfiguration',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationInputKinesisFirehoseInput',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationInputKinesisStreamsInput',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationOutput',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationOutputDestinationSchema',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationOutputKinesisFirehoseOutput',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationOutputKinesisStreamsOutput',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationOutputLambdaOutput',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSource',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchema',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordColumn',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordFormat',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordFormatMappingParameters',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordFormatMappingParametersCsvMappingParameters',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordFormatMappingParametersJsonMappingParameters',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceS3ReferenceDataSource',
    'ApplicationApplicationConfigurationVpcConfiguration',
    'ApplicationCloudwatchLoggingOptions',
]

@pulumi.output_type
class ApplicationApplicationConfiguration(dict):
    def __init__(__self__, *,
                 application_code_configuration: 'outputs.ApplicationApplicationConfigurationApplicationCodeConfiguration',
                 application_snapshot_configuration: Optional['outputs.ApplicationApplicationConfigurationApplicationSnapshotConfiguration'] = None,
                 environment_properties: Optional['outputs.ApplicationApplicationConfigurationEnvironmentProperties'] = None,
                 flink_application_configuration: Optional['outputs.ApplicationApplicationConfigurationFlinkApplicationConfiguration'] = None,
                 sql_application_configuration: Optional['outputs.ApplicationApplicationConfigurationSqlApplicationConfiguration'] = None,
                 vpc_configuration: Optional['outputs.ApplicationApplicationConfigurationVpcConfiguration'] = None):
        """
        :param 'ApplicationApplicationConfigurationApplicationCodeConfigurationArgs' application_code_configuration: The code location and type parameters for the application.
        :param 'ApplicationApplicationConfigurationApplicationSnapshotConfigurationArgs' application_snapshot_configuration: Describes whether snapshots are enabled for a Flink-based application.
        :param 'ApplicationApplicationConfigurationEnvironmentPropertiesArgs' environment_properties: Describes execution properties for a Flink-based application.
        :param 'ApplicationApplicationConfigurationFlinkApplicationConfigurationArgs' flink_application_configuration: The configuration of a Flink-based application.
        :param 'ApplicationApplicationConfigurationSqlApplicationConfigurationArgs' sql_application_configuration: The configuration of a SQL-based application.
        :param 'ApplicationApplicationConfigurationVpcConfigurationArgs' vpc_configuration: The VPC configuration of a Flink-based application.
        """
        pulumi.set(__self__, "application_code_configuration", application_code_configuration)
        if application_snapshot_configuration is not None:
            pulumi.set(__self__, "application_snapshot_configuration", application_snapshot_configuration)
        if environment_properties is not None:
            pulumi.set(__self__, "environment_properties", environment_properties)
        if flink_application_configuration is not None:
            pulumi.set(__self__, "flink_application_configuration", flink_application_configuration)
        if sql_application_configuration is not None:
            pulumi.set(__self__, "sql_application_configuration", sql_application_configuration)
        if vpc_configuration is not None:
            pulumi.set(__self__, "vpc_configuration", vpc_configuration)

    @property
    @pulumi.getter(name="applicationCodeConfiguration")
    def application_code_configuration(self) -> 'outputs.ApplicationApplicationConfigurationApplicationCodeConfiguration':
        """
        The code location and type parameters for the application.
        """
        return pulumi.get(self, "application_code_configuration")

    @property
    @pulumi.getter(name="applicationSnapshotConfiguration")
    def application_snapshot_configuration(self) -> Optional['outputs.ApplicationApplicationConfigurationApplicationSnapshotConfiguration']:
        """
        Describes whether snapshots are enabled for a Flink-based application.
        """
        return pulumi.get(self, "application_snapshot_configuration")

    @property
    @pulumi.getter(name="environmentProperties")
    def environment_properties(self) -> Optional['outputs.ApplicationApplicationConfigurationEnvironmentProperties']:
        """
        Describes execution properties for a Flink-based application.
        """
        return pulumi.get(self, "environment_properties")

    @property
    @pulumi.getter(name="flinkApplicationConfiguration")
    def flink_application_configuration(self) -> Optional['outputs.ApplicationApplicationConfigurationFlinkApplicationConfiguration']:
        """
        The configuration of a Flink-based application.
        """
        return pulumi.get(self, "flink_application_configuration")

    @property
    @pulumi.getter(name="sqlApplicationConfiguration")
    def sql_application_configuration(self) -> Optional['outputs.ApplicationApplicationConfigurationSqlApplicationConfiguration']:
        """
        The configuration of a SQL-based application.
        """
        return pulumi.get(self, "sql_application_configuration")

    @property
    @pulumi.getter(name="vpcConfiguration")
    def vpc_configuration(self) -> Optional['outputs.ApplicationApplicationConfigurationVpcConfiguration']:
        """
        The VPC configuration of a Flink-based application.
        """
        return pulumi.get(self, "vpc_configuration")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationApplicationCodeConfiguration(dict):
    def __init__(__self__, *,
                 code_content_type: str,
                 code_content: Optional['outputs.ApplicationApplicationConfigurationApplicationCodeConfigurationCodeContent'] = None):
        """
        :param str code_content_type: Specifies whether the code content is in text or zip format. Valid values: `PLAINTEXT`, `ZIPFILE`.
        :param 'ApplicationApplicationConfigurationApplicationCodeConfigurationCodeContentArgs' code_content: The location and type of the application code.
        """
        pulumi.set(__self__, "code_content_type", code_content_type)
        if code_content is not None:
            pulumi.set(__self__, "code_content", code_content)

    @property
    @pulumi.getter(name="codeContentType")
    def code_content_type(self) -> str:
        """
        Specifies whether the code content is in text or zip format. Valid values: `PLAINTEXT`, `ZIPFILE`.
        """
        return pulumi.get(self, "code_content_type")

    @property
    @pulumi.getter(name="codeContent")
    def code_content(self) -> Optional['outputs.ApplicationApplicationConfigurationApplicationCodeConfigurationCodeContent']:
        """
        The location and type of the application code.
        """
        return pulumi.get(self, "code_content")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationApplicationCodeConfigurationCodeContent(dict):
    def __init__(__self__, *,
                 s3_content_location: Optional['outputs.ApplicationApplicationConfigurationApplicationCodeConfigurationCodeContentS3ContentLocation'] = None,
                 text_content: Optional[str] = None):
        """
        :param 'ApplicationApplicationConfigurationApplicationCodeConfigurationCodeContentS3ContentLocationArgs' s3_content_location: Information about the Amazon S3 bucket containing the application code.
        :param str text_content: The text-format code for the application.
        """
        if s3_content_location is not None:
            pulumi.set(__self__, "s3_content_location", s3_content_location)
        if text_content is not None:
            pulumi.set(__self__, "text_content", text_content)

    @property
    @pulumi.getter(name="s3ContentLocation")
    def s3_content_location(self) -> Optional['outputs.ApplicationApplicationConfigurationApplicationCodeConfigurationCodeContentS3ContentLocation']:
        """
        Information about the Amazon S3 bucket containing the application code.
        """
        return pulumi.get(self, "s3_content_location")

    @property
    @pulumi.getter(name="textContent")
    def text_content(self) -> Optional[str]:
        """
        The text-format code for the application.
        """
        return pulumi.get(self, "text_content")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationApplicationCodeConfigurationCodeContentS3ContentLocation(dict):
    def __init__(__self__, *,
                 bucket_arn: str,
                 file_key: str,
                 object_version: Optional[str] = None):
        """
        :param str bucket_arn: The ARN for the S3 bucket containing the application code.
        :param str file_key: The file key for the object containing the application code.
        :param str object_version: The version of the object containing the application code.
        """
        pulumi.set(__self__, "bucket_arn", bucket_arn)
        pulumi.set(__self__, "file_key", file_key)
        if object_version is not None:
            pulumi.set(__self__, "object_version", object_version)

    @property
    @pulumi.getter(name="bucketArn")
    def bucket_arn(self) -> str:
        """
        The ARN for the S3 bucket containing the application code.
        """
        return pulumi.get(self, "bucket_arn")

    @property
    @pulumi.getter(name="fileKey")
    def file_key(self) -> str:
        """
        The file key for the object containing the application code.
        """
        return pulumi.get(self, "file_key")

    @property
    @pulumi.getter(name="objectVersion")
    def object_version(self) -> Optional[str]:
        """
        The version of the object containing the application code.
        """
        return pulumi.get(self, "object_version")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationApplicationSnapshotConfiguration(dict):
    def __init__(__self__, *,
                 snapshots_enabled: bool):
        """
        :param bool snapshots_enabled: Describes whether snapshots are enabled for a Flink-based Kinesis Data Analytics application.
        """
        pulumi.set(__self__, "snapshots_enabled", snapshots_enabled)

    @property
    @pulumi.getter(name="snapshotsEnabled")
    def snapshots_enabled(self) -> bool:
        """
        Describes whether snapshots are enabled for a Flink-based Kinesis Data Analytics application.
        """
        return pulumi.get(self, "snapshots_enabled")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationEnvironmentProperties(dict):
    def __init__(__self__, *,
                 property_groups: Sequence['outputs.ApplicationApplicationConfigurationEnvironmentPropertiesPropertyGroup']):
        """
        :param Sequence['ApplicationApplicationConfigurationEnvironmentPropertiesPropertyGroupArgs'] property_groups: Describes the execution property groups.
        """
        pulumi.set(__self__, "property_groups", property_groups)

    @property
    @pulumi.getter(name="propertyGroups")
    def property_groups(self) -> Sequence['outputs.ApplicationApplicationConfigurationEnvironmentPropertiesPropertyGroup']:
        """
        Describes the execution property groups.
        """
        return pulumi.get(self, "property_groups")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationEnvironmentPropertiesPropertyGroup(dict):
    def __init__(__self__, *,
                 property_group_id: str,
                 property_map: Mapping[str, str]):
        """
        :param str property_group_id: The key of the application execution property key-value map.
        :param Mapping[str, str] property_map: Application execution property key-value map.
        """
        pulumi.set(__self__, "property_group_id", property_group_id)
        pulumi.set(__self__, "property_map", property_map)

    @property
    @pulumi.getter(name="propertyGroupId")
    def property_group_id(self) -> str:
        """
        The key of the application execution property key-value map.
        """
        return pulumi.get(self, "property_group_id")

    @property
    @pulumi.getter(name="propertyMap")
    def property_map(self) -> Mapping[str, str]:
        """
        Application execution property key-value map.
        """
        return pulumi.get(self, "property_map")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationFlinkApplicationConfiguration(dict):
    def __init__(__self__, *,
                 checkpoint_configuration: Optional['outputs.ApplicationApplicationConfigurationFlinkApplicationConfigurationCheckpointConfiguration'] = None,
                 monitoring_configuration: Optional['outputs.ApplicationApplicationConfigurationFlinkApplicationConfigurationMonitoringConfiguration'] = None,
                 parallelism_configuration: Optional['outputs.ApplicationApplicationConfigurationFlinkApplicationConfigurationParallelismConfiguration'] = None):
        """
        :param 'ApplicationApplicationConfigurationFlinkApplicationConfigurationCheckpointConfigurationArgs' checkpoint_configuration: Describes an application's checkpointing configuration.
        :param 'ApplicationApplicationConfigurationFlinkApplicationConfigurationMonitoringConfigurationArgs' monitoring_configuration: Describes configuration parameters for CloudWatch logging for an application.
        :param 'ApplicationApplicationConfigurationFlinkApplicationConfigurationParallelismConfigurationArgs' parallelism_configuration: Describes parameters for how an application executes multiple tasks simultaneously.
        """
        if checkpoint_configuration is not None:
            pulumi.set(__self__, "checkpoint_configuration", checkpoint_configuration)
        if monitoring_configuration is not None:
            pulumi.set(__self__, "monitoring_configuration", monitoring_configuration)
        if parallelism_configuration is not None:
            pulumi.set(__self__, "parallelism_configuration", parallelism_configuration)

    @property
    @pulumi.getter(name="checkpointConfiguration")
    def checkpoint_configuration(self) -> Optional['outputs.ApplicationApplicationConfigurationFlinkApplicationConfigurationCheckpointConfiguration']:
        """
        Describes an application's checkpointing configuration.
        """
        return pulumi.get(self, "checkpoint_configuration")

    @property
    @pulumi.getter(name="monitoringConfiguration")
    def monitoring_configuration(self) -> Optional['outputs.ApplicationApplicationConfigurationFlinkApplicationConfigurationMonitoringConfiguration']:
        """
        Describes configuration parameters for CloudWatch logging for an application.
        """
        return pulumi.get(self, "monitoring_configuration")

    @property
    @pulumi.getter(name="parallelismConfiguration")
    def parallelism_configuration(self) -> Optional['outputs.ApplicationApplicationConfigurationFlinkApplicationConfigurationParallelismConfiguration']:
        """
        Describes parameters for how an application executes multiple tasks simultaneously.
        """
        return pulumi.get(self, "parallelism_configuration")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationFlinkApplicationConfigurationCheckpointConfiguration(dict):
    def __init__(__self__, *,
                 configuration_type: str,
                 checkpoint_interval: Optional[int] = None,
                 checkpointing_enabled: Optional[bool] = None,
                 min_pause_between_checkpoints: Optional[int] = None):
        """
        :param str configuration_type: Describes whether the application uses Kinesis Data Analytics' default checkpointing behavior. Valid values: `CUSTOM`, `DEFAULT`. Set this attribute to `CUSTOM` in order for any specified `checkpointing_enabled`, `checkpoint_interval`, or `min_pause_between_checkpoints` attribute values to be effective. If this attribute is set to `DEFAULT`, the application will always use the following values:
               * `checkpointing_enabled = true`
               * `checkpoint_interval = 60000`
               * `min_pause_between_checkpoints = 5000`
        :param int checkpoint_interval: Describes the interval in milliseconds between checkpoint operations.
        :param bool checkpointing_enabled: Describes whether checkpointing is enabled for a Flink-based Kinesis Data Analytics application.
        :param int min_pause_between_checkpoints: Describes the minimum time in milliseconds after a checkpoint operation completes that a new checkpoint operation can start.
        """
        pulumi.set(__self__, "configuration_type", configuration_type)
        if checkpoint_interval is not None:
            pulumi.set(__self__, "checkpoint_interval", checkpoint_interval)
        if checkpointing_enabled is not None:
            pulumi.set(__self__, "checkpointing_enabled", checkpointing_enabled)
        if min_pause_between_checkpoints is not None:
            pulumi.set(__self__, "min_pause_between_checkpoints", min_pause_between_checkpoints)

    @property
    @pulumi.getter(name="configurationType")
    def configuration_type(self) -> str:
        """
        Describes whether the application uses Kinesis Data Analytics' default checkpointing behavior. Valid values: `CUSTOM`, `DEFAULT`. Set this attribute to `CUSTOM` in order for any specified `checkpointing_enabled`, `checkpoint_interval`, or `min_pause_between_checkpoints` attribute values to be effective. If this attribute is set to `DEFAULT`, the application will always use the following values:
        * `checkpointing_enabled = true`
        * `checkpoint_interval = 60000`
        * `min_pause_between_checkpoints = 5000`
        """
        return pulumi.get(self, "configuration_type")

    @property
    @pulumi.getter(name="checkpointInterval")
    def checkpoint_interval(self) -> Optional[int]:
        """
        Describes the interval in milliseconds between checkpoint operations.
        """
        return pulumi.get(self, "checkpoint_interval")

    @property
    @pulumi.getter(name="checkpointingEnabled")
    def checkpointing_enabled(self) -> Optional[bool]:
        """
        Describes whether checkpointing is enabled for a Flink-based Kinesis Data Analytics application.
        """
        return pulumi.get(self, "checkpointing_enabled")

    @property
    @pulumi.getter(name="minPauseBetweenCheckpoints")
    def min_pause_between_checkpoints(self) -> Optional[int]:
        """
        Describes the minimum time in milliseconds after a checkpoint operation completes that a new checkpoint operation can start.
        """
        return pulumi.get(self, "min_pause_between_checkpoints")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationFlinkApplicationConfigurationMonitoringConfiguration(dict):
    def __init__(__self__, *,
                 configuration_type: str,
                 log_level: Optional[str] = None,
                 metrics_level: Optional[str] = None):
        """
        :param str configuration_type: Describes whether to use the default CloudWatch logging configuration for an application. Valid values: `CUSTOM`, `DEFAULT`. Set this attribute to `CUSTOM` in order for any specified `log_level` or `metrics_level` attribute values to be effective.
        :param str log_level: Describes the verbosity of the CloudWatch Logs for an application. Valid values: `DEBUG`, `ERROR`, `INFO`, `WARN`.
        :param str metrics_level: Describes the granularity of the CloudWatch Logs for an application. Valid values: `APPLICATION`, `OPERATOR`, `PARALLELISM`, `TASK`.
        """
        pulumi.set(__self__, "configuration_type", configuration_type)
        if log_level is not None:
            pulumi.set(__self__, "log_level", log_level)
        if metrics_level is not None:
            pulumi.set(__self__, "metrics_level", metrics_level)

    @property
    @pulumi.getter(name="configurationType")
    def configuration_type(self) -> str:
        """
        Describes whether to use the default CloudWatch logging configuration for an application. Valid values: `CUSTOM`, `DEFAULT`. Set this attribute to `CUSTOM` in order for any specified `log_level` or `metrics_level` attribute values to be effective.
        """
        return pulumi.get(self, "configuration_type")

    @property
    @pulumi.getter(name="logLevel")
    def log_level(self) -> Optional[str]:
        """
        Describes the verbosity of the CloudWatch Logs for an application. Valid values: `DEBUG`, `ERROR`, `INFO`, `WARN`.
        """
        return pulumi.get(self, "log_level")

    @property
    @pulumi.getter(name="metricsLevel")
    def metrics_level(self) -> Optional[str]:
        """
        Describes the granularity of the CloudWatch Logs for an application. Valid values: `APPLICATION`, `OPERATOR`, `PARALLELISM`, `TASK`.
        """
        return pulumi.get(self, "metrics_level")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationFlinkApplicationConfigurationParallelismConfiguration(dict):
    def __init__(__self__, *,
                 configuration_type: str,
                 auto_scaling_enabled: Optional[bool] = None,
                 parallelism: Optional[int] = None,
                 parallelism_per_kpu: Optional[int] = None):
        """
        :param str configuration_type: Describes whether the application uses the default parallelism for the Kinesis Data Analytics service. Valid values: `CUSTOM`, `DEFAULT`. Set this attribute to `CUSTOM` in order for any specified `auto_scaling_enabled`, `parallelism`, or `parallelism_per_kpu` attribute values to be effective.
        :param bool auto_scaling_enabled: Describes whether the Kinesis Data Analytics service can increase the parallelism of the application in response to increased throughput.
        :param int parallelism: Describes the initial number of parallel tasks that a Flink-based Kinesis Data Analytics application can perform.
        :param int parallelism_per_kpu: Describes the number of parallel tasks that a Flink-based Kinesis Data Analytics application can perform per Kinesis Processing Unit (KPU) used by the application.
        """
        pulumi.set(__self__, "configuration_type", configuration_type)
        if auto_scaling_enabled is not None:
            pulumi.set(__self__, "auto_scaling_enabled", auto_scaling_enabled)
        if parallelism is not None:
            pulumi.set(__self__, "parallelism", parallelism)
        if parallelism_per_kpu is not None:
            pulumi.set(__self__, "parallelism_per_kpu", parallelism_per_kpu)

    @property
    @pulumi.getter(name="configurationType")
    def configuration_type(self) -> str:
        """
        Describes whether the application uses the default parallelism for the Kinesis Data Analytics service. Valid values: `CUSTOM`, `DEFAULT`. Set this attribute to `CUSTOM` in order for any specified `auto_scaling_enabled`, `parallelism`, or `parallelism_per_kpu` attribute values to be effective.
        """
        return pulumi.get(self, "configuration_type")

    @property
    @pulumi.getter(name="autoScalingEnabled")
    def auto_scaling_enabled(self) -> Optional[bool]:
        """
        Describes whether the Kinesis Data Analytics service can increase the parallelism of the application in response to increased throughput.
        """
        return pulumi.get(self, "auto_scaling_enabled")

    @property
    @pulumi.getter
    def parallelism(self) -> Optional[int]:
        """
        Describes the initial number of parallel tasks that a Flink-based Kinesis Data Analytics application can perform.
        """
        return pulumi.get(self, "parallelism")

    @property
    @pulumi.getter(name="parallelismPerKpu")
    def parallelism_per_kpu(self) -> Optional[int]:
        """
        Describes the number of parallel tasks that a Flink-based Kinesis Data Analytics application can perform per Kinesis Processing Unit (KPU) used by the application.
        """
        return pulumi.get(self, "parallelism_per_kpu")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationSqlApplicationConfiguration(dict):
    def __init__(__self__, *,
                 input: Optional['outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationInput'] = None,
                 outputs: Optional[Sequence['outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationOutput']] = None,
                 reference_data_source: Optional['outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSource'] = None):
        """
        :param 'ApplicationApplicationConfigurationSqlApplicationConfigurationInputArgs' input: The input stream used by the application.
        :param Sequence['ApplicationApplicationConfigurationSqlApplicationConfigurationOutputArgs'] outputs: The destination streams used by the application.
        :param 'ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceArgs' reference_data_source: The reference data source used by the application.
        """
        if input is not None:
            pulumi.set(__self__, "input", input)
        if outputs is not None:
            pulumi.set(__self__, "outputs", outputs)
        if reference_data_source is not None:
            pulumi.set(__self__, "reference_data_source", reference_data_source)

    @property
    @pulumi.getter
    def input(self) -> Optional['outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationInput']:
        """
        The input stream used by the application.
        """
        return pulumi.get(self, "input")

    @property
    @pulumi.getter
    def outputs(self) -> Optional[Sequence['outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationOutput']]:
        """
        The destination streams used by the application.
        """
        return pulumi.get(self, "outputs")

    @property
    @pulumi.getter(name="referenceDataSource")
    def reference_data_source(self) -> Optional['outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSource']:
        """
        The reference data source used by the application.
        """
        return pulumi.get(self, "reference_data_source")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationInput(dict):
    def __init__(__self__, *,
                 input_schema: 'outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchema',
                 name_prefix: str,
                 in_app_stream_names: Optional[Sequence[str]] = None,
                 input_id: Optional[str] = None,
                 input_parallelism: Optional['outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputParallelism'] = None,
                 input_processing_configuration: Optional['outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputProcessingConfiguration'] = None,
                 input_starting_position_configurations: Optional[Sequence['outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputStartingPositionConfiguration']] = None,
                 kinesis_firehose_input: Optional['outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationInputKinesisFirehoseInput'] = None,
                 kinesis_streams_input: Optional['outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationInputKinesisStreamsInput'] = None):
        """
        :param 'ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaArgs' input_schema: Describes the format of the data in the streaming source, and how each data element maps to corresponding columns in the in-application stream that is being created.
        :param str name_prefix: The name prefix to use when creating an in-application stream.
        :param 'ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputParallelismArgs' input_parallelism: Describes the number of in-application streams to create.
        :param 'ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputProcessingConfigurationArgs' input_processing_configuration: The input processing configuration for the input.
               An input processor transforms records as they are received from the stream, before the application's SQL code executes.
        :param 'ApplicationApplicationConfigurationSqlApplicationConfigurationInputKinesisFirehoseInputArgs' kinesis_firehose_input: If the streaming source is a [Kinesis Data Firehose delivery stream](https://www.terraform.io/docs/providers/aws/r/kinesis_firehose_delivery_stream.html), identifies the delivery stream's ARN.
        :param 'ApplicationApplicationConfigurationSqlApplicationConfigurationInputKinesisStreamsInputArgs' kinesis_streams_input: If the streaming source is a [Kinesis data stream](https://www.terraform.io/docs/providers/aws/r/kinesis_stream.html), identifies the stream's Amazon Resource Name (ARN).
        """
        pulumi.set(__self__, "input_schema", input_schema)
        pulumi.set(__self__, "name_prefix", name_prefix)
        if in_app_stream_names is not None:
            pulumi.set(__self__, "in_app_stream_names", in_app_stream_names)
        if input_id is not None:
            pulumi.set(__self__, "input_id", input_id)
        if input_parallelism is not None:
            pulumi.set(__self__, "input_parallelism", input_parallelism)
        if input_processing_configuration is not None:
            pulumi.set(__self__, "input_processing_configuration", input_processing_configuration)
        if input_starting_position_configurations is not None:
            pulumi.set(__self__, "input_starting_position_configurations", input_starting_position_configurations)
        if kinesis_firehose_input is not None:
            pulumi.set(__self__, "kinesis_firehose_input", kinesis_firehose_input)
        if kinesis_streams_input is not None:
            pulumi.set(__self__, "kinesis_streams_input", kinesis_streams_input)

    @property
    @pulumi.getter(name="inputSchema")
    def input_schema(self) -> 'outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchema':
        """
        Describes the format of the data in the streaming source, and how each data element maps to corresponding columns in the in-application stream that is being created.
        """
        return pulumi.get(self, "input_schema")

    @property
    @pulumi.getter(name="namePrefix")
    def name_prefix(self) -> str:
        """
        The name prefix to use when creating an in-application stream.
        """
        return pulumi.get(self, "name_prefix")

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

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

    @property
    @pulumi.getter(name="inputParallelism")
    def input_parallelism(self) -> Optional['outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputParallelism']:
        """
        Describes the number of in-application streams to create.
        """
        return pulumi.get(self, "input_parallelism")

    @property
    @pulumi.getter(name="inputProcessingConfiguration")
    def input_processing_configuration(self) -> Optional['outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputProcessingConfiguration']:
        """
        The input processing configuration for the input.
        An input processor transforms records as they are received from the stream, before the application's SQL code executes.
        """
        return pulumi.get(self, "input_processing_configuration")

    @property
    @pulumi.getter(name="inputStartingPositionConfigurations")
    def input_starting_position_configurations(self) -> Optional[Sequence['outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputStartingPositionConfiguration']]:
        return pulumi.get(self, "input_starting_position_configurations")

    @property
    @pulumi.getter(name="kinesisFirehoseInput")
    def kinesis_firehose_input(self) -> Optional['outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationInputKinesisFirehoseInput']:
        """
        If the streaming source is a [Kinesis Data Firehose delivery stream](https://www.terraform.io/docs/providers/aws/r/kinesis_firehose_delivery_stream.html), identifies the delivery stream's ARN.
        """
        return pulumi.get(self, "kinesis_firehose_input")

    @property
    @pulumi.getter(name="kinesisStreamsInput")
    def kinesis_streams_input(self) -> Optional['outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationInputKinesisStreamsInput']:
        """
        If the streaming source is a [Kinesis data stream](https://www.terraform.io/docs/providers/aws/r/kinesis_stream.html), identifies the stream's Amazon Resource Name (ARN).
        """
        return pulumi.get(self, "kinesis_streams_input")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputParallelism(dict):
    def __init__(__self__, *,
                 count: Optional[int] = None):
        """
        :param int count: The number of in-application streams to create.
        """
        if count is not None:
            pulumi.set(__self__, "count", count)

    @property
    @pulumi.getter
    def count(self) -> Optional[int]:
        """
        The number of in-application streams to create.
        """
        return pulumi.get(self, "count")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputProcessingConfiguration(dict):
    def __init__(__self__, *,
                 input_lambda_processor: 'outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputProcessingConfigurationInputLambdaProcessor'):
        """
        :param 'ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputProcessingConfigurationInputLambdaProcessorArgs' input_lambda_processor: Describes the [Lambda function](https://www.terraform.io/docs/providers/aws/r/lambda_function.html) that is used to preprocess the records in the stream before being processed by your application code.
        """
        pulumi.set(__self__, "input_lambda_processor", input_lambda_processor)

    @property
    @pulumi.getter(name="inputLambdaProcessor")
    def input_lambda_processor(self) -> 'outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputProcessingConfigurationInputLambdaProcessor':
        """
        Describes the [Lambda function](https://www.terraform.io/docs/providers/aws/r/lambda_function.html) that is used to preprocess the records in the stream before being processed by your application code.
        """
        return pulumi.get(self, "input_lambda_processor")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputProcessingConfigurationInputLambdaProcessor(dict):
    def __init__(__self__, *,
                 resource_arn: str):
        """
        :param str resource_arn: The ARN of the Lambda function that operates on records in the stream.
        """
        pulumi.set(__self__, "resource_arn", resource_arn)

    @property
    @pulumi.getter(name="resourceArn")
    def resource_arn(self) -> str:
        """
        The ARN of the Lambda function that operates on records in the stream.
        """
        return pulumi.get(self, "resource_arn")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchema(dict):
    def __init__(__self__, *,
                 record_columns: Sequence['outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordColumn'],
                 record_format: 'outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordFormat',
                 record_encoding: Optional[str] = None):
        """
        :param Sequence['ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordColumnArgs'] record_columns: Describes the mapping of each data element in the streaming source to the corresponding column in the in-application stream.
        :param 'ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordFormatArgs' record_format: Specifies the format of the records on the streaming source.
        :param str record_encoding: Specifies the encoding of the records in the streaming source. For example, `UTF-8`.
        """
        pulumi.set(__self__, "record_columns", record_columns)
        pulumi.set(__self__, "record_format", record_format)
        if record_encoding is not None:
            pulumi.set(__self__, "record_encoding", record_encoding)

    @property
    @pulumi.getter(name="recordColumns")
    def record_columns(self) -> Sequence['outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordColumn']:
        """
        Describes the mapping of each data element in the streaming source to the corresponding column in the in-application stream.
        """
        return pulumi.get(self, "record_columns")

    @property
    @pulumi.getter(name="recordFormat")
    def record_format(self) -> 'outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordFormat':
        """
        Specifies the format of the records on the streaming source.
        """
        return pulumi.get(self, "record_format")

    @property
    @pulumi.getter(name="recordEncoding")
    def record_encoding(self) -> Optional[str]:
        """
        Specifies the encoding of the records in the streaming source. For example, `UTF-8`.
        """
        return pulumi.get(self, "record_encoding")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordColumn(dict):
    def __init__(__self__, *,
                 name: str,
                 sql_type: str,
                 mapping: Optional[str] = None):
        """
        :param str name: The name of the column that is created in the in-application input stream or reference table.
        :param str sql_type: The type of column created in the in-application input stream or reference table.
        :param str mapping: A reference to the data element in the streaming input or the reference data source.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "sql_type", sql_type)
        if mapping is not None:
            pulumi.set(__self__, "mapping", mapping)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the column that is created in the in-application input stream or reference table.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="sqlType")
    def sql_type(self) -> str:
        """
        The type of column created in the in-application input stream or reference table.
        """
        return pulumi.get(self, "sql_type")

    @property
    @pulumi.getter
    def mapping(self) -> Optional[str]:
        """
        A reference to the data element in the streaming input or the reference data source.
        """
        return pulumi.get(self, "mapping")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordFormat(dict):
    def __init__(__self__, *,
                 mapping_parameters: 'outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordFormatMappingParameters',
                 record_format_type: str):
        """
        :param 'ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordFormatMappingParametersArgs' mapping_parameters: Provides additional mapping information specific to the record format (such as JSON, CSV, or record fields delimited by some delimiter) on the streaming source.
        :param str record_format_type: The type of record format. Valid values: `CSV`, `JSON`.
        """
        pulumi.set(__self__, "mapping_parameters", mapping_parameters)
        pulumi.set(__self__, "record_format_type", record_format_type)

    @property
    @pulumi.getter(name="mappingParameters")
    def mapping_parameters(self) -> 'outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordFormatMappingParameters':
        """
        Provides additional mapping information specific to the record format (such as JSON, CSV, or record fields delimited by some delimiter) on the streaming source.
        """
        return pulumi.get(self, "mapping_parameters")

    @property
    @pulumi.getter(name="recordFormatType")
    def record_format_type(self) -> str:
        """
        The type of record format. Valid values: `CSV`, `JSON`.
        """
        return pulumi.get(self, "record_format_type")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordFormatMappingParameters(dict):
    def __init__(__self__, *,
                 csv_mapping_parameters: Optional['outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordFormatMappingParametersCsvMappingParameters'] = None,
                 json_mapping_parameters: Optional['outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordFormatMappingParametersJsonMappingParameters'] = None):
        """
        :param 'ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordFormatMappingParametersCsvMappingParametersArgs' csv_mapping_parameters: Provides additional mapping information when the record format uses delimiters (for example, CSV).
        :param 'ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordFormatMappingParametersJsonMappingParametersArgs' json_mapping_parameters: Provides additional mapping information when JSON is the record format on the streaming source.
        """
        if csv_mapping_parameters is not None:
            pulumi.set(__self__, "csv_mapping_parameters", csv_mapping_parameters)
        if json_mapping_parameters is not None:
            pulumi.set(__self__, "json_mapping_parameters", json_mapping_parameters)

    @property
    @pulumi.getter(name="csvMappingParameters")
    def csv_mapping_parameters(self) -> Optional['outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordFormatMappingParametersCsvMappingParameters']:
        """
        Provides additional mapping information when the record format uses delimiters (for example, CSV).
        """
        return pulumi.get(self, "csv_mapping_parameters")

    @property
    @pulumi.getter(name="jsonMappingParameters")
    def json_mapping_parameters(self) -> Optional['outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordFormatMappingParametersJsonMappingParameters']:
        """
        Provides additional mapping information when JSON is the record format on the streaming source.
        """
        return pulumi.get(self, "json_mapping_parameters")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordFormatMappingParametersCsvMappingParameters(dict):
    def __init__(__self__, *,
                 record_column_delimiter: str,
                 record_row_delimiter: str):
        """
        :param str record_column_delimiter: The column delimiter. For example, in a CSV format, a comma (`,`) is the typical column delimiter.
        :param str record_row_delimiter: The row delimiter. For example, in a CSV format, `\n` is the typical row delimiter.
        """
        pulumi.set(__self__, "record_column_delimiter", record_column_delimiter)
        pulumi.set(__self__, "record_row_delimiter", record_row_delimiter)

    @property
    @pulumi.getter(name="recordColumnDelimiter")
    def record_column_delimiter(self) -> str:
        """
        The column delimiter. For example, in a CSV format, a comma (`,`) is the typical column delimiter.
        """
        return pulumi.get(self, "record_column_delimiter")

    @property
    @pulumi.getter(name="recordRowDelimiter")
    def record_row_delimiter(self) -> str:
        """
        The row delimiter. For example, in a CSV format, `\n` is the typical row delimiter.
        """
        return pulumi.get(self, "record_row_delimiter")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordFormatMappingParametersJsonMappingParameters(dict):
    def __init__(__self__, *,
                 record_row_path: str):
        """
        :param str record_row_path: The path to the top-level parent that contains the records.
        """
        pulumi.set(__self__, "record_row_path", record_row_path)

    @property
    @pulumi.getter(name="recordRowPath")
    def record_row_path(self) -> str:
        """
        The path to the top-level parent that contains the records.
        """
        return pulumi.get(self, "record_row_path")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationInputKinesisFirehoseInput(dict):
    def __init__(__self__, *,
                 resource_arn: str):
        """
        :param str resource_arn: The ARN of the delivery stream.
        """
        pulumi.set(__self__, "resource_arn", resource_arn)

    @property
    @pulumi.getter(name="resourceArn")
    def resource_arn(self) -> str:
        """
        The ARN of the delivery stream.
        """
        return pulumi.get(self, "resource_arn")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationInputKinesisStreamsInput(dict):
    def __init__(__self__, *,
                 resource_arn: str):
        """
        :param str resource_arn: The ARN of the input Kinesis data stream to read.
        """
        pulumi.set(__self__, "resource_arn", resource_arn)

    @property
    @pulumi.getter(name="resourceArn")
    def resource_arn(self) -> str:
        """
        The ARN of the input Kinesis data stream to read.
        """
        return pulumi.get(self, "resource_arn")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationOutput(dict):
    def __init__(__self__, *,
                 destination_schema: 'outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationOutputDestinationSchema',
                 name: str,
                 kinesis_firehose_output: Optional['outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationOutputKinesisFirehoseOutput'] = None,
                 kinesis_streams_output: Optional['outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationOutputKinesisStreamsOutput'] = None,
                 lambda_output: Optional['outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationOutputLambdaOutput'] = None,
                 output_id: Optional[str] = None):
        """
        :param 'ApplicationApplicationConfigurationSqlApplicationConfigurationOutputDestinationSchemaArgs' destination_schema: Describes the data format when records are written to the destination.
        :param str name: The name of the in-application stream.
        :param 'ApplicationApplicationConfigurationSqlApplicationConfigurationOutputKinesisFirehoseOutputArgs' kinesis_firehose_output: Identifies a [Kinesis Data Firehose delivery stream](https://www.terraform.io/docs/providers/aws/r/kinesis_firehose_delivery_stream.html) as the destination.
        :param 'ApplicationApplicationConfigurationSqlApplicationConfigurationOutputKinesisStreamsOutputArgs' kinesis_streams_output: Identifies a [Kinesis data stream](https://www.terraform.io/docs/providers/aws/r/kinesis_stream.html) as the destination.
        :param 'ApplicationApplicationConfigurationSqlApplicationConfigurationOutputLambdaOutputArgs' lambda_output: Identifies a [Lambda function](https://www.terraform.io/docs/providers/aws/r/lambda_function.html) as the destination.
        """
        pulumi.set(__self__, "destination_schema", destination_schema)
        pulumi.set(__self__, "name", name)
        if kinesis_firehose_output is not None:
            pulumi.set(__self__, "kinesis_firehose_output", kinesis_firehose_output)
        if kinesis_streams_output is not None:
            pulumi.set(__self__, "kinesis_streams_output", kinesis_streams_output)
        if lambda_output is not None:
            pulumi.set(__self__, "lambda_output", lambda_output)
        if output_id is not None:
            pulumi.set(__self__, "output_id", output_id)

    @property
    @pulumi.getter(name="destinationSchema")
    def destination_schema(self) -> 'outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationOutputDestinationSchema':
        """
        Describes the data format when records are written to the destination.
        """
        return pulumi.get(self, "destination_schema")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the in-application stream.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="kinesisFirehoseOutput")
    def kinesis_firehose_output(self) -> Optional['outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationOutputKinesisFirehoseOutput']:
        """
        Identifies a [Kinesis Data Firehose delivery stream](https://www.terraform.io/docs/providers/aws/r/kinesis_firehose_delivery_stream.html) as the destination.
        """
        return pulumi.get(self, "kinesis_firehose_output")

    @property
    @pulumi.getter(name="kinesisStreamsOutput")
    def kinesis_streams_output(self) -> Optional['outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationOutputKinesisStreamsOutput']:
        """
        Identifies a [Kinesis data stream](https://www.terraform.io/docs/providers/aws/r/kinesis_stream.html) as the destination.
        """
        return pulumi.get(self, "kinesis_streams_output")

    @property
    @pulumi.getter(name="lambdaOutput")
    def lambda_output(self) -> Optional['outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationOutputLambdaOutput']:
        """
        Identifies a [Lambda function](https://www.terraform.io/docs/providers/aws/r/lambda_function.html) as the destination.
        """
        return pulumi.get(self, "lambda_output")

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationOutputDestinationSchema(dict):
    def __init__(__self__, *,
                 record_format_type: str):
        """
        :param str record_format_type: Specifies the format of the records on the output stream. Valid values: `CSV`, `JSON`.
        """
        pulumi.set(__self__, "record_format_type", record_format_type)

    @property
    @pulumi.getter(name="recordFormatType")
    def record_format_type(self) -> str:
        """
        Specifies the format of the records on the output stream. Valid values: `CSV`, `JSON`.
        """
        return pulumi.get(self, "record_format_type")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationOutputKinesisFirehoseOutput(dict):
    def __init__(__self__, *,
                 resource_arn: str):
        """
        :param str resource_arn: The ARN of the destination delivery stream to write to.
        """
        pulumi.set(__self__, "resource_arn", resource_arn)

    @property
    @pulumi.getter(name="resourceArn")
    def resource_arn(self) -> str:
        """
        The ARN of the destination delivery stream to write to.
        """
        return pulumi.get(self, "resource_arn")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationOutputKinesisStreamsOutput(dict):
    def __init__(__self__, *,
                 resource_arn: str):
        """
        :param str resource_arn: The ARN of the destination Kinesis data stream to write to.
        """
        pulumi.set(__self__, "resource_arn", resource_arn)

    @property
    @pulumi.getter(name="resourceArn")
    def resource_arn(self) -> str:
        """
        The ARN of the destination Kinesis data stream to write to.
        """
        return pulumi.get(self, "resource_arn")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationOutputLambdaOutput(dict):
    def __init__(__self__, *,
                 resource_arn: str):
        """
        :param str resource_arn: The ARN of the destination Lambda function to write to.
        """
        pulumi.set(__self__, "resource_arn", resource_arn)

    @property
    @pulumi.getter(name="resourceArn")
    def resource_arn(self) -> str:
        """
        The ARN of the destination Lambda function to write to.
        """
        return pulumi.get(self, "resource_arn")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSource(dict):
    def __init__(__self__, *,
                 reference_schema: 'outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchema',
                 s3_reference_data_source: 'outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceS3ReferenceDataSource',
                 table_name: str,
                 reference_id: Optional[str] = None):
        """
        :param 'ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaArgs' reference_schema: Describes the format of the data in the streaming source, and how each data element maps to corresponding columns created in the in-application stream.
        :param 'ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceS3ReferenceDataSourceArgs' s3_reference_data_source: Identifies the S3 bucket and object that contains the reference data.
        :param str table_name: The name of the in-application table to create.
        """
        pulumi.set(__self__, "reference_schema", reference_schema)
        pulumi.set(__self__, "s3_reference_data_source", s3_reference_data_source)
        pulumi.set(__self__, "table_name", table_name)
        if reference_id is not None:
            pulumi.set(__self__, "reference_id", reference_id)

    @property
    @pulumi.getter(name="referenceSchema")
    def reference_schema(self) -> 'outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchema':
        """
        Describes the format of the data in the streaming source, and how each data element maps to corresponding columns created in the in-application stream.
        """
        return pulumi.get(self, "reference_schema")

    @property
    @pulumi.getter(name="s3ReferenceDataSource")
    def s3_reference_data_source(self) -> 'outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceS3ReferenceDataSource':
        """
        Identifies the S3 bucket and object that contains the reference data.
        """
        return pulumi.get(self, "s3_reference_data_source")

    @property
    @pulumi.getter(name="tableName")
    def table_name(self) -> str:
        """
        The name of the in-application table to create.
        """
        return pulumi.get(self, "table_name")

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchema(dict):
    def __init__(__self__, *,
                 record_columns: Sequence['outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordColumn'],
                 record_format: 'outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordFormat',
                 record_encoding: Optional[str] = None):
        """
        :param Sequence['ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordColumnArgs'] record_columns: Describes the mapping of each data element in the streaming source to the corresponding column in the in-application stream.
        :param 'ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordFormatArgs' record_format: Specifies the format of the records on the streaming source.
        :param str record_encoding: Specifies the encoding of the records in the streaming source. For example, `UTF-8`.
        """
        pulumi.set(__self__, "record_columns", record_columns)
        pulumi.set(__self__, "record_format", record_format)
        if record_encoding is not None:
            pulumi.set(__self__, "record_encoding", record_encoding)

    @property
    @pulumi.getter(name="recordColumns")
    def record_columns(self) -> Sequence['outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordColumn']:
        """
        Describes the mapping of each data element in the streaming source to the corresponding column in the in-application stream.
        """
        return pulumi.get(self, "record_columns")

    @property
    @pulumi.getter(name="recordFormat")
    def record_format(self) -> 'outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordFormat':
        """
        Specifies the format of the records on the streaming source.
        """
        return pulumi.get(self, "record_format")

    @property
    @pulumi.getter(name="recordEncoding")
    def record_encoding(self) -> Optional[str]:
        """
        Specifies the encoding of the records in the streaming source. For example, `UTF-8`.
        """
        return pulumi.get(self, "record_encoding")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordColumn(dict):
    def __init__(__self__, *,
                 name: str,
                 sql_type: str,
                 mapping: Optional[str] = None):
        """
        :param str name: The name of the column that is created in the in-application input stream or reference table.
        :param str sql_type: The type of column created in the in-application input stream or reference table.
        :param str mapping: A reference to the data element in the streaming input or the reference data source.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "sql_type", sql_type)
        if mapping is not None:
            pulumi.set(__self__, "mapping", mapping)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the column that is created in the in-application input stream or reference table.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="sqlType")
    def sql_type(self) -> str:
        """
        The type of column created in the in-application input stream or reference table.
        """
        return pulumi.get(self, "sql_type")

    @property
    @pulumi.getter
    def mapping(self) -> Optional[str]:
        """
        A reference to the data element in the streaming input or the reference data source.
        """
        return pulumi.get(self, "mapping")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordFormat(dict):
    def __init__(__self__, *,
                 mapping_parameters: 'outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordFormatMappingParameters',
                 record_format_type: str):
        """
        :param 'ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordFormatMappingParametersArgs' mapping_parameters: Provides additional mapping information specific to the record format (such as JSON, CSV, or record fields delimited by some delimiter) on the streaming source.
        :param str record_format_type: The type of record format. Valid values: `CSV`, `JSON`.
        """
        pulumi.set(__self__, "mapping_parameters", mapping_parameters)
        pulumi.set(__self__, "record_format_type", record_format_type)

    @property
    @pulumi.getter(name="mappingParameters")
    def mapping_parameters(self) -> 'outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordFormatMappingParameters':
        """
        Provides additional mapping information specific to the record format (such as JSON, CSV, or record fields delimited by some delimiter) on the streaming source.
        """
        return pulumi.get(self, "mapping_parameters")

    @property
    @pulumi.getter(name="recordFormatType")
    def record_format_type(self) -> str:
        """
        The type of record format. Valid values: `CSV`, `JSON`.
        """
        return pulumi.get(self, "record_format_type")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordFormatMappingParameters(dict):
    def __init__(__self__, *,
                 csv_mapping_parameters: Optional['outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordFormatMappingParametersCsvMappingParameters'] = None,
                 json_mapping_parameters: Optional['outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordFormatMappingParametersJsonMappingParameters'] = None):
        """
        :param 'ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordFormatMappingParametersCsvMappingParametersArgs' csv_mapping_parameters: Provides additional mapping information when the record format uses delimiters (for example, CSV).
        :param 'ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordFormatMappingParametersJsonMappingParametersArgs' json_mapping_parameters: Provides additional mapping information when JSON is the record format on the streaming source.
        """
        if csv_mapping_parameters is not None:
            pulumi.set(__self__, "csv_mapping_parameters", csv_mapping_parameters)
        if json_mapping_parameters is not None:
            pulumi.set(__self__, "json_mapping_parameters", json_mapping_parameters)

    @property
    @pulumi.getter(name="csvMappingParameters")
    def csv_mapping_parameters(self) -> Optional['outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordFormatMappingParametersCsvMappingParameters']:
        """
        Provides additional mapping information when the record format uses delimiters (for example, CSV).
        """
        return pulumi.get(self, "csv_mapping_parameters")

    @property
    @pulumi.getter(name="jsonMappingParameters")
    def json_mapping_parameters(self) -> Optional['outputs.ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordFormatMappingParametersJsonMappingParameters']:
        """
        Provides additional mapping information when JSON is the record format on the streaming source.
        """
        return pulumi.get(self, "json_mapping_parameters")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordFormatMappingParametersCsvMappingParameters(dict):
    def __init__(__self__, *,
                 record_column_delimiter: str,
                 record_row_delimiter: str):
        """
        :param str record_column_delimiter: The column delimiter. For example, in a CSV format, a comma (`,`) is the typical column delimiter.
        :param str record_row_delimiter: The row delimiter. For example, in a CSV format, `\n` is the typical row delimiter.
        """
        pulumi.set(__self__, "record_column_delimiter", record_column_delimiter)
        pulumi.set(__self__, "record_row_delimiter", record_row_delimiter)

    @property
    @pulumi.getter(name="recordColumnDelimiter")
    def record_column_delimiter(self) -> str:
        """
        The column delimiter. For example, in a CSV format, a comma (`,`) is the typical column delimiter.
        """
        return pulumi.get(self, "record_column_delimiter")

    @property
    @pulumi.getter(name="recordRowDelimiter")
    def record_row_delimiter(self) -> str:
        """
        The row delimiter. For example, in a CSV format, `\n` is the typical row delimiter.
        """
        return pulumi.get(self, "record_row_delimiter")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordFormatMappingParametersJsonMappingParameters(dict):
    def __init__(__self__, *,
                 record_row_path: str):
        """
        :param str record_row_path: The path to the top-level parent that contains the records.
        """
        pulumi.set(__self__, "record_row_path", record_row_path)

    @property
    @pulumi.getter(name="recordRowPath")
    def record_row_path(self) -> str:
        """
        The path to the top-level parent that contains the records.
        """
        return pulumi.get(self, "record_row_path")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceS3ReferenceDataSource(dict):
    def __init__(__self__, *,
                 bucket_arn: str,
                 file_key: str):
        """
        :param str bucket_arn: The ARN for the S3 bucket containing the application code.
        :param str file_key: The file key for the object containing the application code.
        """
        pulumi.set(__self__, "bucket_arn", bucket_arn)
        pulumi.set(__self__, "file_key", file_key)

    @property
    @pulumi.getter(name="bucketArn")
    def bucket_arn(self) -> str:
        """
        The ARN for the S3 bucket containing the application code.
        """
        return pulumi.get(self, "bucket_arn")

    @property
    @pulumi.getter(name="fileKey")
    def file_key(self) -> str:
        """
        The file key for the object containing the application code.
        """
        return pulumi.get(self, "file_key")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationApplicationConfigurationVpcConfiguration(dict):
    def __init__(__self__, *,
                 security_group_ids: Sequence[str],
                 subnet_ids: Sequence[str],
                 vpc_configuration_id: Optional[str] = None,
                 vpc_id: Optional[str] = None):
        """
        :param Sequence[str] security_group_ids: The [Security Group](https://www.terraform.io/docs/providers/aws/r/security_group.html) IDs used by the VPC configuration.
        :param Sequence[str] subnet_ids: The [Subnet](https://www.terraform.io/docs/providers/aws/r/subnet.html) IDs used by the VPC configuration.
        """
        pulumi.set(__self__, "security_group_ids", security_group_ids)
        pulumi.set(__self__, "subnet_ids", subnet_ids)
        if vpc_configuration_id is not None:
            pulumi.set(__self__, "vpc_configuration_id", vpc_configuration_id)
        if vpc_id is not None:
            pulumi.set(__self__, "vpc_id", vpc_id)

    @property
    @pulumi.getter(name="securityGroupIds")
    def security_group_ids(self) -> Sequence[str]:
        """
        The [Security Group](https://www.terraform.io/docs/providers/aws/r/security_group.html) IDs used by the VPC configuration.
        """
        return pulumi.get(self, "security_group_ids")

    @property
    @pulumi.getter(name="subnetIds")
    def subnet_ids(self) -> Sequence[str]:
        """
        The [Subnet](https://www.terraform.io/docs/providers/aws/r/subnet.html) IDs used by the VPC configuration.
        """
        return pulumi.get(self, "subnet_ids")

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationCloudwatchLoggingOptions(dict):
    def __init__(__self__, *,
                 log_stream_arn: str,
                 cloudwatch_logging_option_id: Optional[str] = None):
        """
        :param str log_stream_arn: The ARN of the CloudWatch log stream to receive application messages.
        """
        pulumi.set(__self__, "log_stream_arn", log_stream_arn)
        if cloudwatch_logging_option_id is not None:
            pulumi.set(__self__, "cloudwatch_logging_option_id", cloudwatch_logging_option_id)

    @property
    @pulumi.getter(name="logStreamArn")
    def log_stream_arn(self) -> str:
        """
        The ARN of the CloudWatch log stream to receive application messages.
        """
        return pulumi.get(self, "log_stream_arn")

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


