# 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

__all__ = [
    'ApplicationApplicationConfigurationArgs',
    'ApplicationApplicationConfigurationApplicationCodeConfigurationArgs',
    'ApplicationApplicationConfigurationApplicationCodeConfigurationCodeContentArgs',
    'ApplicationApplicationConfigurationApplicationCodeConfigurationCodeContentS3ContentLocationArgs',
    'ApplicationApplicationConfigurationApplicationSnapshotConfigurationArgs',
    'ApplicationApplicationConfigurationEnvironmentPropertiesArgs',
    'ApplicationApplicationConfigurationEnvironmentPropertiesPropertyGroupArgs',
    'ApplicationApplicationConfigurationFlinkApplicationConfigurationArgs',
    'ApplicationApplicationConfigurationFlinkApplicationConfigurationCheckpointConfigurationArgs',
    'ApplicationApplicationConfigurationFlinkApplicationConfigurationMonitoringConfigurationArgs',
    'ApplicationApplicationConfigurationFlinkApplicationConfigurationParallelismConfigurationArgs',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationArgs',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationInputArgs',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputParallelismArgs',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputProcessingConfigurationArgs',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputProcessingConfigurationInputLambdaProcessorArgs',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaArgs',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordColumnArgs',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordFormatArgs',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordFormatMappingParametersArgs',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordFormatMappingParametersCsvMappingParametersArgs',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordFormatMappingParametersJsonMappingParametersArgs',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputStartingPositionConfigurationArgs',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationInputKinesisFirehoseInputArgs',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationInputKinesisStreamsInputArgs',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationOutputArgs',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationOutputDestinationSchemaArgs',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationOutputKinesisFirehoseOutputArgs',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationOutputKinesisStreamsOutputArgs',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationOutputLambdaOutputArgs',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceArgs',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaArgs',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordColumnArgs',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordFormatArgs',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordFormatMappingParametersArgs',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordFormatMappingParametersCsvMappingParametersArgs',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordFormatMappingParametersJsonMappingParametersArgs',
    'ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceS3ReferenceDataSourceArgs',
    'ApplicationApplicationConfigurationVpcConfigurationArgs',
    'ApplicationCloudwatchLoggingOptionsArgs',
]

@pulumi.input_type
class ApplicationApplicationConfigurationArgs:
    def __init__(__self__, *,
                 application_code_configuration: pulumi.Input['ApplicationApplicationConfigurationApplicationCodeConfigurationArgs'],
                 application_snapshot_configuration: Optional[pulumi.Input['ApplicationApplicationConfigurationApplicationSnapshotConfigurationArgs']] = None,
                 environment_properties: Optional[pulumi.Input['ApplicationApplicationConfigurationEnvironmentPropertiesArgs']] = None,
                 flink_application_configuration: Optional[pulumi.Input['ApplicationApplicationConfigurationFlinkApplicationConfigurationArgs']] = None,
                 sql_application_configuration: Optional[pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationArgs']] = None,
                 vpc_configuration: Optional[pulumi.Input['ApplicationApplicationConfigurationVpcConfigurationArgs']] = None):
        """
        :param pulumi.Input['ApplicationApplicationConfigurationApplicationCodeConfigurationArgs'] application_code_configuration: The code location and type parameters for the application.
        :param pulumi.Input['ApplicationApplicationConfigurationApplicationSnapshotConfigurationArgs'] application_snapshot_configuration: Describes whether snapshots are enabled for a Flink-based application.
        :param pulumi.Input['ApplicationApplicationConfigurationEnvironmentPropertiesArgs'] environment_properties: Describes execution properties for a Flink-based application.
        :param pulumi.Input['ApplicationApplicationConfigurationFlinkApplicationConfigurationArgs'] flink_application_configuration: The configuration of a Flink-based application.
        :param pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationArgs'] sql_application_configuration: The configuration of a SQL-based application.
        :param pulumi.Input['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) -> pulumi.Input['ApplicationApplicationConfigurationApplicationCodeConfigurationArgs']:
        """
        The code location and type parameters for the application.
        """
        return pulumi.get(self, "application_code_configuration")

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class ApplicationApplicationConfigurationApplicationCodeConfigurationArgs:
    def __init__(__self__, *,
                 code_content_type: pulumi.Input[str],
                 code_content: Optional[pulumi.Input['ApplicationApplicationConfigurationApplicationCodeConfigurationCodeContentArgs']] = None):
        """
        :param pulumi.Input[str] code_content_type: Specifies whether the code content is in text or zip format. Valid values: `PLAINTEXT`, `ZIPFILE`.
        :param pulumi.Input['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) -> pulumi.Input[str]:
        """
        Specifies whether the code content is in text or zip format. Valid values: `PLAINTEXT`, `ZIPFILE`.
        """
        return pulumi.get(self, "code_content_type")

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

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

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


@pulumi.input_type
class ApplicationApplicationConfigurationApplicationCodeConfigurationCodeContentArgs:
    def __init__(__self__, *,
                 s3_content_location: Optional[pulumi.Input['ApplicationApplicationConfigurationApplicationCodeConfigurationCodeContentS3ContentLocationArgs']] = None,
                 text_content: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['ApplicationApplicationConfigurationApplicationCodeConfigurationCodeContentS3ContentLocationArgs'] s3_content_location: Information about the Amazon S3 bucket containing the application code.
        :param pulumi.Input[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[pulumi.Input['ApplicationApplicationConfigurationApplicationCodeConfigurationCodeContentS3ContentLocationArgs']]:
        """
        Information about the Amazon S3 bucket containing the application code.
        """
        return pulumi.get(self, "s3_content_location")

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

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

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


@pulumi.input_type
class ApplicationApplicationConfigurationApplicationCodeConfigurationCodeContentS3ContentLocationArgs:
    def __init__(__self__, *,
                 bucket_arn: pulumi.Input[str],
                 file_key: pulumi.Input[str],
                 object_version: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] bucket_arn: The ARN for the S3 bucket containing the application code.
        :param pulumi.Input[str] file_key: The file key for the object containing the application code.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ARN for the S3 bucket containing the application code.
        """
        return pulumi.get(self, "bucket_arn")

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

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

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

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

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


@pulumi.input_type
class ApplicationApplicationConfigurationApplicationSnapshotConfigurationArgs:
    def __init__(__self__, *,
                 snapshots_enabled: pulumi.Input[bool]):
        """
        :param pulumi.Input[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) -> pulumi.Input[bool]:
        """
        Describes whether snapshots are enabled for a Flink-based Kinesis Data Analytics application.
        """
        return pulumi.get(self, "snapshots_enabled")

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


@pulumi.input_type
class ApplicationApplicationConfigurationEnvironmentPropertiesArgs:
    def __init__(__self__, *,
                 property_groups: pulumi.Input[Sequence[pulumi.Input['ApplicationApplicationConfigurationEnvironmentPropertiesPropertyGroupArgs']]]):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ApplicationApplicationConfigurationEnvironmentPropertiesPropertyGroupArgs']]] property_groups: Describes the execution property groups.
        """
        pulumi.set(__self__, "property_groups", property_groups)

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

    @property_groups.setter
    def property_groups(self, value: pulumi.Input[Sequence[pulumi.Input['ApplicationApplicationConfigurationEnvironmentPropertiesPropertyGroupArgs']]]):
        pulumi.set(self, "property_groups", value)


@pulumi.input_type
class ApplicationApplicationConfigurationEnvironmentPropertiesPropertyGroupArgs:
    def __init__(__self__, *,
                 property_group_id: pulumi.Input[str],
                 property_map: pulumi.Input[Mapping[str, pulumi.Input[str]]]):
        """
        :param pulumi.Input[str] property_group_id: The key of the application execution property key-value map.
        :param pulumi.Input[Mapping[str, pulumi.Input[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) -> pulumi.Input[str]:
        """
        The key of the application execution property key-value map.
        """
        return pulumi.get(self, "property_group_id")

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

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

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


@pulumi.input_type
class ApplicationApplicationConfigurationFlinkApplicationConfigurationArgs:
    def __init__(__self__, *,
                 checkpoint_configuration: Optional[pulumi.Input['ApplicationApplicationConfigurationFlinkApplicationConfigurationCheckpointConfigurationArgs']] = None,
                 monitoring_configuration: Optional[pulumi.Input['ApplicationApplicationConfigurationFlinkApplicationConfigurationMonitoringConfigurationArgs']] = None,
                 parallelism_configuration: Optional[pulumi.Input['ApplicationApplicationConfigurationFlinkApplicationConfigurationParallelismConfigurationArgs']] = None):
        """
        :param pulumi.Input['ApplicationApplicationConfigurationFlinkApplicationConfigurationCheckpointConfigurationArgs'] checkpoint_configuration: Describes an application's checkpointing configuration.
        :param pulumi.Input['ApplicationApplicationConfigurationFlinkApplicationConfigurationMonitoringConfigurationArgs'] monitoring_configuration: Describes configuration parameters for CloudWatch logging for an application.
        :param pulumi.Input['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[pulumi.Input['ApplicationApplicationConfigurationFlinkApplicationConfigurationCheckpointConfigurationArgs']]:
        """
        Describes an application's checkpointing configuration.
        """
        return pulumi.get(self, "checkpoint_configuration")

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

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

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

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

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


@pulumi.input_type
class ApplicationApplicationConfigurationFlinkApplicationConfigurationCheckpointConfigurationArgs:
    def __init__(__self__, *,
                 configuration_type: pulumi.Input[str],
                 checkpoint_interval: Optional[pulumi.Input[int]] = None,
                 checkpointing_enabled: Optional[pulumi.Input[bool]] = None,
                 min_pause_between_checkpoints: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[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 pulumi.Input[int] checkpoint_interval: Describes the interval in milliseconds between checkpoint operations.
        :param pulumi.Input[bool] checkpointing_enabled: Describes whether checkpointing is enabled for a Flink-based Kinesis Data Analytics application.
        :param pulumi.Input[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) -> pulumi.Input[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")

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

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

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

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

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

    @property
    @pulumi.getter(name="minPauseBetweenCheckpoints")
    def min_pause_between_checkpoints(self) -> Optional[pulumi.Input[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")

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


@pulumi.input_type
class ApplicationApplicationConfigurationFlinkApplicationConfigurationMonitoringConfigurationArgs:
    def __init__(__self__, *,
                 configuration_type: pulumi.Input[str],
                 log_level: Optional[pulumi.Input[str]] = None,
                 metrics_level: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[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 pulumi.Input[str] log_level: Describes the verbosity of the CloudWatch Logs for an application. Valid values: `DEBUG`, `ERROR`, `INFO`, `WARN`.
        :param pulumi.Input[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) -> pulumi.Input[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")

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

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

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

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

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


@pulumi.input_type
class ApplicationApplicationConfigurationFlinkApplicationConfigurationParallelismConfigurationArgs:
    def __init__(__self__, *,
                 configuration_type: pulumi.Input[str],
                 auto_scaling_enabled: Optional[pulumi.Input[bool]] = None,
                 parallelism: Optional[pulumi.Input[int]] = None,
                 parallelism_per_kpu: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[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 pulumi.Input[bool] auto_scaling_enabled: Describes whether the Kinesis Data Analytics service can increase the parallelism of the application in response to increased throughput.
        :param pulumi.Input[int] parallelism: Describes the initial number of parallel tasks that a Flink-based Kinesis Data Analytics application can perform.
        :param pulumi.Input[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) -> pulumi.Input[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")

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

    @property
    @pulumi.getter(name="autoScalingEnabled")
    def auto_scaling_enabled(self) -> Optional[pulumi.Input[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")

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

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

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

    @property
    @pulumi.getter(name="parallelismPerKpu")
    def parallelism_per_kpu(self) -> Optional[pulumi.Input[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")

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


@pulumi.input_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationArgs:
    def __init__(__self__, *,
                 input: Optional[pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationInputArgs']] = None,
                 outputs: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationOutputArgs']]]] = None,
                 reference_data_source: Optional[pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceArgs']] = None):
        """
        :param pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationInputArgs'] input: The input stream used by the application.
        :param pulumi.Input[Sequence[pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationOutputArgs']]] outputs: The destination streams used by the application.
        :param pulumi.Input['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[pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationInputArgs']]:
        """
        The input stream used by the application.
        """
        return pulumi.get(self, "input")

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

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

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

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

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


@pulumi.input_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationInputArgs:
    def __init__(__self__, *,
                 input_schema: pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaArgs'],
                 name_prefix: pulumi.Input[str],
                 in_app_stream_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 input_id: Optional[pulumi.Input[str]] = None,
                 input_parallelism: Optional[pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputParallelismArgs']] = None,
                 input_processing_configuration: Optional[pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputProcessingConfigurationArgs']] = None,
                 input_starting_position_configurations: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputStartingPositionConfigurationArgs']]]] = None,
                 kinesis_firehose_input: Optional[pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationInputKinesisFirehoseInputArgs']] = None,
                 kinesis_streams_input: Optional[pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationInputKinesisStreamsInputArgs']] = None):
        """
        :param pulumi.Input['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 pulumi.Input[str] name_prefix: The name prefix to use when creating an in-application stream.
        :param pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputParallelismArgs'] input_parallelism: Describes the number of in-application streams to create.
        :param pulumi.Input['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 pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationInputKinesisFirehoseInputArgs'] kinesis_firehose_input: If the streaming source is a Kinesis Data Firehose delivery stream, identifies the delivery stream's ARN.
        :param pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationInputKinesisStreamsInputArgs'] kinesis_streams_input: If the streaming source is a Kinesis data stream, 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) -> pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaArgs']:
        """
        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")

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="inputProcessingConfiguration")
    def input_processing_configuration(self) -> Optional[pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputProcessingConfigurationArgs']]:
        """
        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")

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

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

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

    @property
    @pulumi.getter(name="kinesisFirehoseInput")
    def kinesis_firehose_input(self) -> Optional[pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationInputKinesisFirehoseInputArgs']]:
        """
        If the streaming source is a Kinesis Data Firehose delivery stream, identifies the delivery stream's ARN.
        """
        return pulumi.get(self, "kinesis_firehose_input")

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

    @property
    @pulumi.getter(name="kinesisStreamsInput")
    def kinesis_streams_input(self) -> Optional[pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationInputKinesisStreamsInputArgs']]:
        """
        If the streaming source is a Kinesis data stream, identifies the stream's Amazon Resource Name (ARN).
        """
        return pulumi.get(self, "kinesis_streams_input")

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


@pulumi.input_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputParallelismArgs:
    def __init__(__self__, *,
                 count: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[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[pulumi.Input[int]]:
        """
        The number of in-application streams to create.
        """
        return pulumi.get(self, "count")

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


@pulumi.input_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputProcessingConfigurationArgs:
    def __init__(__self__, *,
                 input_lambda_processor: pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputProcessingConfigurationInputLambdaProcessorArgs']):
        """
        :param pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputProcessingConfigurationInputLambdaProcessorArgs'] input_lambda_processor: Describes the Lambda function 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) -> pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputProcessingConfigurationInputLambdaProcessorArgs']:
        """
        Describes the Lambda function that is used to preprocess the records in the stream before being processed by your application code.
        """
        return pulumi.get(self, "input_lambda_processor")

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


@pulumi.input_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputProcessingConfigurationInputLambdaProcessorArgs:
    def __init__(__self__, *,
                 resource_arn: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ARN of the Lambda function that operates on records in the stream.
        """
        return pulumi.get(self, "resource_arn")

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


@pulumi.input_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaArgs:
    def __init__(__self__, *,
                 record_columns: pulumi.Input[Sequence[pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordColumnArgs']]],
                 record_format: pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordFormatArgs'],
                 record_encoding: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordColumnArgs']]] record_columns: Describes the mapping of each data element in the streaming source to the corresponding column in the in-application stream.
        :param pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordFormatArgs'] record_format: Specifies the format of the records on the streaming source.
        :param pulumi.Input[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) -> pulumi.Input[Sequence[pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordColumnArgs']]]:
        """
        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")

    @record_columns.setter
    def record_columns(self, value: pulumi.Input[Sequence[pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordColumnArgs']]]):
        pulumi.set(self, "record_columns", value)

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

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

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

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


@pulumi.input_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordColumnArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 sql_type: pulumi.Input[str],
                 mapping: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The name of the column that is created in the in-application input stream or reference table.
        :param pulumi.Input[str] sql_type: The type of column created in the in-application input stream or reference table.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The name of the column that is created in the in-application input stream or reference table.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordFormatArgs:
    def __init__(__self__, *,
                 mapping_parameters: pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordFormatMappingParametersArgs'],
                 record_format_type: pulumi.Input[str]):
        """
        :param pulumi.Input['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 pulumi.Input[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) -> pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordFormatMappingParametersArgs']:
        """
        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")

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

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

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


@pulumi.input_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordFormatMappingParametersArgs:
    def __init__(__self__, *,
                 csv_mapping_parameters: Optional[pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordFormatMappingParametersCsvMappingParametersArgs']] = None,
                 json_mapping_parameters: Optional[pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordFormatMappingParametersJsonMappingParametersArgs']] = None):
        """
        :param pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordFormatMappingParametersCsvMappingParametersArgs'] csv_mapping_parameters: Provides additional mapping information when the record format uses delimiters (for example, CSV).
        :param pulumi.Input['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[pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordFormatMappingParametersCsvMappingParametersArgs']]:
        """
        Provides additional mapping information when the record format uses delimiters (for example, CSV).
        """
        return pulumi.get(self, "csv_mapping_parameters")

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

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

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


@pulumi.input_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordFormatMappingParametersCsvMappingParametersArgs:
    def __init__(__self__, *,
                 record_column_delimiter: pulumi.Input[str],
                 record_row_delimiter: pulumi.Input[str]):
        """
        :param pulumi.Input[str] record_column_delimiter: The column delimiter. For example, in a CSV format, a comma (`,`) is the typical column delimiter.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The column delimiter. For example, in a CSV format, a comma (`,`) is the typical column delimiter.
        """
        return pulumi.get(self, "record_column_delimiter")

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

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

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


@pulumi.input_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputSchemaRecordFormatMappingParametersJsonMappingParametersArgs:
    def __init__(__self__, *,
                 record_row_path: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The path to the top-level parent that contains the records.
        """
        return pulumi.get(self, "record_row_path")

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


@pulumi.input_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationInputInputStartingPositionConfigurationArgs:
    def __init__(__self__, *,
                 input_starting_position: Optional[pulumi.Input[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[pulumi.Input[str]]:
        return pulumi.get(self, "input_starting_position")

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


@pulumi.input_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationInputKinesisFirehoseInputArgs:
    def __init__(__self__, *,
                 resource_arn: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ARN of the delivery stream.
        """
        return pulumi.get(self, "resource_arn")

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


@pulumi.input_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationInputKinesisStreamsInputArgs:
    def __init__(__self__, *,
                 resource_arn: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ARN of the input Kinesis data stream to read.
        """
        return pulumi.get(self, "resource_arn")

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


@pulumi.input_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationOutputArgs:
    def __init__(__self__, *,
                 destination_schema: pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationOutputDestinationSchemaArgs'],
                 name: pulumi.Input[str],
                 kinesis_firehose_output: Optional[pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationOutputKinesisFirehoseOutputArgs']] = None,
                 kinesis_streams_output: Optional[pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationOutputKinesisStreamsOutputArgs']] = None,
                 lambda_output: Optional[pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationOutputLambdaOutputArgs']] = None,
                 output_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationOutputDestinationSchemaArgs'] destination_schema: Describes the data format when records are written to the destination.
        :param pulumi.Input[str] name: The name of the in-application stream.
        :param pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationOutputKinesisFirehoseOutputArgs'] kinesis_firehose_output: Identifies a Kinesis Data Firehose delivery stream as the destination.
        :param pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationOutputKinesisStreamsOutputArgs'] kinesis_streams_output: Identifies a Kinesis data stream as the destination.
        :param pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationOutputLambdaOutputArgs'] lambda_output: Identifies a Lambda function 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) -> pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationOutputDestinationSchemaArgs']:
        """
        Describes the data format when records are written to the destination.
        """
        return pulumi.get(self, "destination_schema")

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

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

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

    @property
    @pulumi.getter(name="kinesisFirehoseOutput")
    def kinesis_firehose_output(self) -> Optional[pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationOutputKinesisFirehoseOutputArgs']]:
        """
        Identifies a Kinesis Data Firehose delivery stream as the destination.
        """
        return pulumi.get(self, "kinesis_firehose_output")

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

    @property
    @pulumi.getter(name="kinesisStreamsOutput")
    def kinesis_streams_output(self) -> Optional[pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationOutputKinesisStreamsOutputArgs']]:
        """
        Identifies a Kinesis data stream as the destination.
        """
        return pulumi.get(self, "kinesis_streams_output")

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

    @property
    @pulumi.getter(name="lambdaOutput")
    def lambda_output(self) -> Optional[pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationOutputLambdaOutputArgs']]:
        """
        Identifies a Lambda function as the destination.
        """
        return pulumi.get(self, "lambda_output")

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

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

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


@pulumi.input_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationOutputDestinationSchemaArgs:
    def __init__(__self__, *,
                 record_format_type: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        Specifies the format of the records on the output stream. Valid values: `CSV`, `JSON`.
        """
        return pulumi.get(self, "record_format_type")

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


@pulumi.input_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationOutputKinesisFirehoseOutputArgs:
    def __init__(__self__, *,
                 resource_arn: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ARN of the destination delivery stream to write to.
        """
        return pulumi.get(self, "resource_arn")

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


@pulumi.input_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationOutputKinesisStreamsOutputArgs:
    def __init__(__self__, *,
                 resource_arn: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ARN of the destination Kinesis data stream to write to.
        """
        return pulumi.get(self, "resource_arn")

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


@pulumi.input_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationOutputLambdaOutputArgs:
    def __init__(__self__, *,
                 resource_arn: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ARN of the destination Lambda function to write to.
        """
        return pulumi.get(self, "resource_arn")

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


@pulumi.input_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceArgs:
    def __init__(__self__, *,
                 reference_schema: pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaArgs'],
                 s3_reference_data_source: pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceS3ReferenceDataSourceArgs'],
                 table_name: pulumi.Input[str],
                 reference_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['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 pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceS3ReferenceDataSourceArgs'] s3_reference_data_source: Identifies the S3 bucket and object that contains the reference data.
        :param pulumi.Input[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) -> pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaArgs']:
        """
        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")

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

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

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

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

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

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

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


@pulumi.input_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaArgs:
    def __init__(__self__, *,
                 record_columns: pulumi.Input[Sequence[pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordColumnArgs']]],
                 record_format: pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordFormatArgs'],
                 record_encoding: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordColumnArgs']]] record_columns: Describes the mapping of each data element in the streaming source to the corresponding column in the in-application stream.
        :param pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordFormatArgs'] record_format: Specifies the format of the records on the streaming source.
        :param pulumi.Input[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) -> pulumi.Input[Sequence[pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordColumnArgs']]]:
        """
        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")

    @record_columns.setter
    def record_columns(self, value: pulumi.Input[Sequence[pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordColumnArgs']]]):
        pulumi.set(self, "record_columns", value)

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

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

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

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


@pulumi.input_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordColumnArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 sql_type: pulumi.Input[str],
                 mapping: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The name of the column that is created in the in-application input stream or reference table.
        :param pulumi.Input[str] sql_type: The type of column created in the in-application input stream or reference table.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The name of the column that is created in the in-application input stream or reference table.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordFormatArgs:
    def __init__(__self__, *,
                 mapping_parameters: pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordFormatMappingParametersArgs'],
                 record_format_type: pulumi.Input[str]):
        """
        :param pulumi.Input['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 pulumi.Input[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) -> pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordFormatMappingParametersArgs']:
        """
        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")

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

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

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


@pulumi.input_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordFormatMappingParametersArgs:
    def __init__(__self__, *,
                 csv_mapping_parameters: Optional[pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordFormatMappingParametersCsvMappingParametersArgs']] = None,
                 json_mapping_parameters: Optional[pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordFormatMappingParametersJsonMappingParametersArgs']] = None):
        """
        :param pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordFormatMappingParametersCsvMappingParametersArgs'] csv_mapping_parameters: Provides additional mapping information when the record format uses delimiters (for example, CSV).
        :param pulumi.Input['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[pulumi.Input['ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordFormatMappingParametersCsvMappingParametersArgs']]:
        """
        Provides additional mapping information when the record format uses delimiters (for example, CSV).
        """
        return pulumi.get(self, "csv_mapping_parameters")

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

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

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


@pulumi.input_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordFormatMappingParametersCsvMappingParametersArgs:
    def __init__(__self__, *,
                 record_column_delimiter: pulumi.Input[str],
                 record_row_delimiter: pulumi.Input[str]):
        """
        :param pulumi.Input[str] record_column_delimiter: The column delimiter. For example, in a CSV format, a comma (`,`) is the typical column delimiter.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The column delimiter. For example, in a CSV format, a comma (`,`) is the typical column delimiter.
        """
        return pulumi.get(self, "record_column_delimiter")

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

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

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


@pulumi.input_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceReferenceSchemaRecordFormatMappingParametersJsonMappingParametersArgs:
    def __init__(__self__, *,
                 record_row_path: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The path to the top-level parent that contains the records.
        """
        return pulumi.get(self, "record_row_path")

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


@pulumi.input_type
class ApplicationApplicationConfigurationSqlApplicationConfigurationReferenceDataSourceS3ReferenceDataSourceArgs:
    def __init__(__self__, *,
                 bucket_arn: pulumi.Input[str],
                 file_key: pulumi.Input[str]):
        """
        :param pulumi.Input[str] bucket_arn: The ARN for the S3 bucket containing the application code.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ARN for the S3 bucket containing the application code.
        """
        return pulumi.get(self, "bucket_arn")

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

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

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


@pulumi.input_type
class ApplicationApplicationConfigurationVpcConfigurationArgs:
    def __init__(__self__, *,
                 security_group_ids: pulumi.Input[Sequence[pulumi.Input[str]]],
                 subnet_ids: pulumi.Input[Sequence[pulumi.Input[str]]],
                 vpc_configuration_id: Optional[pulumi.Input[str]] = None,
                 vpc_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] security_group_ids: The Security Group IDs used by the VPC configuration.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] subnet_ids: The Subnet 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) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        The Security Group IDs used by the VPC configuration.
        """
        return pulumi.get(self, "security_group_ids")

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

    @property
    @pulumi.getter(name="subnetIds")
    def subnet_ids(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        The Subnet IDs used by the VPC configuration.
        """
        return pulumi.get(self, "subnet_ids")

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

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

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

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

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


@pulumi.input_type
class ApplicationCloudwatchLoggingOptionsArgs:
    def __init__(__self__, *,
                 log_stream_arn: pulumi.Input[str],
                 cloudwatch_logging_option_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ARN of the CloudWatch log stream to receive application messages.
        """
        return pulumi.get(self, "log_stream_arn")

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

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

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


