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

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

__all__ = [
    'ApplicationCSVMappingParameters',
    'ApplicationInput',
    'ApplicationInputLambdaProcessor',
    'ApplicationInputParallelism',
    'ApplicationInputProcessingConfiguration',
    'ApplicationInputSchema',
    'ApplicationJSONMappingParameters',
    'ApplicationKinesisFirehoseInput',
    'ApplicationKinesisStreamsInput',
    'ApplicationMappingParameters',
    'ApplicationOutputResourceDestinationSchema',
    'ApplicationOutputResourceKinesisFirehoseOutput',
    'ApplicationOutputResourceKinesisStreamsOutput',
    'ApplicationOutputResourceLambdaOutput',
    'ApplicationOutputResourceOutput',
    'ApplicationRecordColumn',
    'ApplicationRecordFormat',
    'ApplicationReferenceDataSourceCSVMappingParameters',
    'ApplicationReferenceDataSourceJSONMappingParameters',
    'ApplicationReferenceDataSourceMappingParameters',
    'ApplicationReferenceDataSourceRecordColumn',
    'ApplicationReferenceDataSourceRecordFormat',
    'ApplicationReferenceDataSourceReferenceDataSource',
    'ApplicationReferenceDataSourceReferenceSchema',
    'ApplicationReferenceDataSourceS3ReferenceDataSource',
]

@pulumi.output_type
class ApplicationCSVMappingParameters(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "recordColumnDelimiter":
            suggest = "record_column_delimiter"
        elif key == "recordRowDelimiter":
            suggest = "record_row_delimiter"

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

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

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

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

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

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


@pulumi.output_type
class ApplicationInput(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "inputSchema":
            suggest = "input_schema"
        elif key == "namePrefix":
            suggest = "name_prefix"
        elif key == "inputParallelism":
            suggest = "input_parallelism"
        elif key == "inputProcessingConfiguration":
            suggest = "input_processing_configuration"
        elif key == "kinesisFirehoseInput":
            suggest = "kinesis_firehose_input"
        elif key == "kinesisStreamsInput":
            suggest = "kinesis_streams_input"

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

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

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

    def __init__(__self__, *,
                 input_schema: 'outputs.ApplicationInputSchema',
                 name_prefix: str,
                 input_parallelism: Optional['outputs.ApplicationInputParallelism'] = None,
                 input_processing_configuration: Optional['outputs.ApplicationInputProcessingConfiguration'] = None,
                 kinesis_firehose_input: Optional['outputs.ApplicationKinesisFirehoseInput'] = None,
                 kinesis_streams_input: Optional['outputs.ApplicationKinesisStreamsInput'] = None):
        pulumi.set(__self__, "input_schema", input_schema)
        pulumi.set(__self__, "name_prefix", name_prefix)
        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 kinesis_firehose_input is not None:
            pulumi.set(__self__, "kinesis_firehose_input", kinesis_firehose_input)
        if kinesis_streams_input is not None:
            pulumi.set(__self__, "kinesis_streams_input", kinesis_streams_input)

    @property
    @pulumi.getter(name="inputSchema")
    def input_schema(self) -> 'outputs.ApplicationInputSchema':
        return pulumi.get(self, "input_schema")

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

    @property
    @pulumi.getter(name="inputParallelism")
    def input_parallelism(self) -> Optional['outputs.ApplicationInputParallelism']:
        return pulumi.get(self, "input_parallelism")

    @property
    @pulumi.getter(name="inputProcessingConfiguration")
    def input_processing_configuration(self) -> Optional['outputs.ApplicationInputProcessingConfiguration']:
        return pulumi.get(self, "input_processing_configuration")

    @property
    @pulumi.getter(name="kinesisFirehoseInput")
    def kinesis_firehose_input(self) -> Optional['outputs.ApplicationKinesisFirehoseInput']:
        return pulumi.get(self, "kinesis_firehose_input")

    @property
    @pulumi.getter(name="kinesisStreamsInput")
    def kinesis_streams_input(self) -> Optional['outputs.ApplicationKinesisStreamsInput']:
        return pulumi.get(self, "kinesis_streams_input")


@pulumi.output_type
class ApplicationInputLambdaProcessor(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resourceARN":
            suggest = "resource_arn"
        elif key == "roleARN":
            suggest = "role_arn"

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

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

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

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

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

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


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

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


@pulumi.output_type
class ApplicationInputProcessingConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "inputLambdaProcessor":
            suggest = "input_lambda_processor"

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

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

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

    def __init__(__self__, *,
                 input_lambda_processor: Optional['outputs.ApplicationInputLambdaProcessor'] = None):
        if input_lambda_processor is not None:
            pulumi.set(__self__, "input_lambda_processor", input_lambda_processor)

    @property
    @pulumi.getter(name="inputLambdaProcessor")
    def input_lambda_processor(self) -> Optional['outputs.ApplicationInputLambdaProcessor']:
        return pulumi.get(self, "input_lambda_processor")


@pulumi.output_type
class ApplicationInputSchema(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "recordColumns":
            suggest = "record_columns"
        elif key == "recordFormat":
            suggest = "record_format"
        elif key == "recordEncoding":
            suggest = "record_encoding"

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

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

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

    def __init__(__self__, *,
                 record_columns: Sequence['outputs.ApplicationRecordColumn'],
                 record_format: 'outputs.ApplicationRecordFormat',
                 record_encoding: Optional[str] = None):
        pulumi.set(__self__, "record_columns", record_columns)
        pulumi.set(__self__, "record_format", record_format)
        if record_encoding is not None:
            pulumi.set(__self__, "record_encoding", record_encoding)

    @property
    @pulumi.getter(name="recordColumns")
    def record_columns(self) -> Sequence['outputs.ApplicationRecordColumn']:
        return pulumi.get(self, "record_columns")

    @property
    @pulumi.getter(name="recordFormat")
    def record_format(self) -> 'outputs.ApplicationRecordFormat':
        return pulumi.get(self, "record_format")

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


@pulumi.output_type
class ApplicationJSONMappingParameters(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "recordRowPath":
            suggest = "record_row_path"

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

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

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

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

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


@pulumi.output_type
class ApplicationKinesisFirehoseInput(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resourceARN":
            suggest = "resource_arn"
        elif key == "roleARN":
            suggest = "role_arn"

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

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

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

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

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

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


@pulumi.output_type
class ApplicationKinesisStreamsInput(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resourceARN":
            suggest = "resource_arn"
        elif key == "roleARN":
            suggest = "role_arn"

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

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

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

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

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

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


@pulumi.output_type
class ApplicationMappingParameters(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cSVMappingParameters":
            suggest = "c_sv_mapping_parameters"
        elif key == "jSONMappingParameters":
            suggest = "j_son_mapping_parameters"

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

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

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

    def __init__(__self__, *,
                 c_sv_mapping_parameters: Optional['outputs.ApplicationCSVMappingParameters'] = None,
                 j_son_mapping_parameters: Optional['outputs.ApplicationJSONMappingParameters'] = None):
        if c_sv_mapping_parameters is not None:
            pulumi.set(__self__, "c_sv_mapping_parameters", c_sv_mapping_parameters)
        if j_son_mapping_parameters is not None:
            pulumi.set(__self__, "j_son_mapping_parameters", j_son_mapping_parameters)

    @property
    @pulumi.getter(name="cSVMappingParameters")
    def c_sv_mapping_parameters(self) -> Optional['outputs.ApplicationCSVMappingParameters']:
        return pulumi.get(self, "c_sv_mapping_parameters")

    @property
    @pulumi.getter(name="jSONMappingParameters")
    def j_son_mapping_parameters(self) -> Optional['outputs.ApplicationJSONMappingParameters']:
        return pulumi.get(self, "j_son_mapping_parameters")


@pulumi.output_type
class ApplicationOutputResourceDestinationSchema(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "recordFormatType":
            suggest = "record_format_type"

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

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

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

    def __init__(__self__, *,
                 record_format_type: Optional[str] = None):
        if record_format_type is not None:
            pulumi.set(__self__, "record_format_type", record_format_type)

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


@pulumi.output_type
class ApplicationOutputResourceKinesisFirehoseOutput(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resourceARN":
            suggest = "resource_arn"
        elif key == "roleARN":
            suggest = "role_arn"

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

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

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

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

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

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


@pulumi.output_type
class ApplicationOutputResourceKinesisStreamsOutput(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resourceARN":
            suggest = "resource_arn"
        elif key == "roleARN":
            suggest = "role_arn"

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

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

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

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

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

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


@pulumi.output_type
class ApplicationOutputResourceLambdaOutput(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resourceARN":
            suggest = "resource_arn"
        elif key == "roleARN":
            suggest = "role_arn"

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

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

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

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

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

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


@pulumi.output_type
class ApplicationOutputResourceOutput(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "destinationSchema":
            suggest = "destination_schema"
        elif key == "kinesisFirehoseOutput":
            suggest = "kinesis_firehose_output"
        elif key == "kinesisStreamsOutput":
            suggest = "kinesis_streams_output"
        elif key == "lambdaOutput":
            suggest = "lambda_output"

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

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

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

    def __init__(__self__, *,
                 destination_schema: 'outputs.ApplicationOutputResourceDestinationSchema',
                 kinesis_firehose_output: Optional['outputs.ApplicationOutputResourceKinesisFirehoseOutput'] = None,
                 kinesis_streams_output: Optional['outputs.ApplicationOutputResourceKinesisStreamsOutput'] = None,
                 lambda_output: Optional['outputs.ApplicationOutputResourceLambdaOutput'] = None,
                 name: Optional[str] = None):
        pulumi.set(__self__, "destination_schema", destination_schema)
        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 name is not None:
            pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter(name="destinationSchema")
    def destination_schema(self) -> 'outputs.ApplicationOutputResourceDestinationSchema':
        return pulumi.get(self, "destination_schema")

    @property
    @pulumi.getter(name="kinesisFirehoseOutput")
    def kinesis_firehose_output(self) -> Optional['outputs.ApplicationOutputResourceKinesisFirehoseOutput']:
        return pulumi.get(self, "kinesis_firehose_output")

    @property
    @pulumi.getter(name="kinesisStreamsOutput")
    def kinesis_streams_output(self) -> Optional['outputs.ApplicationOutputResourceKinesisStreamsOutput']:
        return pulumi.get(self, "kinesis_streams_output")

    @property
    @pulumi.getter(name="lambdaOutput")
    def lambda_output(self) -> Optional['outputs.ApplicationOutputResourceLambdaOutput']:
        return pulumi.get(self, "lambda_output")

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


@pulumi.output_type
class ApplicationRecordColumn(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "sqlType":
            suggest = "sql_type"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 sql_type: str,
                 mapping: Optional[str] = None):
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "sql_type", sql_type)
        if mapping is not None:
            pulumi.set(__self__, "mapping", mapping)

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

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

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


@pulumi.output_type
class ApplicationRecordFormat(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "recordFormatType":
            suggest = "record_format_type"
        elif key == "mappingParameters":
            suggest = "mapping_parameters"

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

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

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

    def __init__(__self__, *,
                 record_format_type: str,
                 mapping_parameters: Optional['outputs.ApplicationMappingParameters'] = None):
        pulumi.set(__self__, "record_format_type", record_format_type)
        if mapping_parameters is not None:
            pulumi.set(__self__, "mapping_parameters", mapping_parameters)

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

    @property
    @pulumi.getter(name="mappingParameters")
    def mapping_parameters(self) -> Optional['outputs.ApplicationMappingParameters']:
        return pulumi.get(self, "mapping_parameters")


@pulumi.output_type
class ApplicationReferenceDataSourceCSVMappingParameters(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "recordColumnDelimiter":
            suggest = "record_column_delimiter"
        elif key == "recordRowDelimiter":
            suggest = "record_row_delimiter"

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

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

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

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

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

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


@pulumi.output_type
class ApplicationReferenceDataSourceJSONMappingParameters(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "recordRowPath":
            suggest = "record_row_path"

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

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

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

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

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


@pulumi.output_type
class ApplicationReferenceDataSourceMappingParameters(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cSVMappingParameters":
            suggest = "c_sv_mapping_parameters"
        elif key == "jSONMappingParameters":
            suggest = "j_son_mapping_parameters"

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

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

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

    def __init__(__self__, *,
                 c_sv_mapping_parameters: Optional['outputs.ApplicationReferenceDataSourceCSVMappingParameters'] = None,
                 j_son_mapping_parameters: Optional['outputs.ApplicationReferenceDataSourceJSONMappingParameters'] = None):
        if c_sv_mapping_parameters is not None:
            pulumi.set(__self__, "c_sv_mapping_parameters", c_sv_mapping_parameters)
        if j_son_mapping_parameters is not None:
            pulumi.set(__self__, "j_son_mapping_parameters", j_son_mapping_parameters)

    @property
    @pulumi.getter(name="cSVMappingParameters")
    def c_sv_mapping_parameters(self) -> Optional['outputs.ApplicationReferenceDataSourceCSVMappingParameters']:
        return pulumi.get(self, "c_sv_mapping_parameters")

    @property
    @pulumi.getter(name="jSONMappingParameters")
    def j_son_mapping_parameters(self) -> Optional['outputs.ApplicationReferenceDataSourceJSONMappingParameters']:
        return pulumi.get(self, "j_son_mapping_parameters")


@pulumi.output_type
class ApplicationReferenceDataSourceRecordColumn(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "sqlType":
            suggest = "sql_type"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 sql_type: str,
                 mapping: Optional[str] = None):
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "sql_type", sql_type)
        if mapping is not None:
            pulumi.set(__self__, "mapping", mapping)

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

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

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


@pulumi.output_type
class ApplicationReferenceDataSourceRecordFormat(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "recordFormatType":
            suggest = "record_format_type"
        elif key == "mappingParameters":
            suggest = "mapping_parameters"

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

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

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

    def __init__(__self__, *,
                 record_format_type: str,
                 mapping_parameters: Optional['outputs.ApplicationReferenceDataSourceMappingParameters'] = None):
        pulumi.set(__self__, "record_format_type", record_format_type)
        if mapping_parameters is not None:
            pulumi.set(__self__, "mapping_parameters", mapping_parameters)

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

    @property
    @pulumi.getter(name="mappingParameters")
    def mapping_parameters(self) -> Optional['outputs.ApplicationReferenceDataSourceMappingParameters']:
        return pulumi.get(self, "mapping_parameters")


@pulumi.output_type
class ApplicationReferenceDataSourceReferenceDataSource(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "referenceSchema":
            suggest = "reference_schema"
        elif key == "s3ReferenceDataSource":
            suggest = "s3_reference_data_source"
        elif key == "tableName":
            suggest = "table_name"

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

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

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

    def __init__(__self__, *,
                 reference_schema: 'outputs.ApplicationReferenceDataSourceReferenceSchema',
                 s3_reference_data_source: Optional['outputs.ApplicationReferenceDataSourceS3ReferenceDataSource'] = None,
                 table_name: Optional[str] = None):
        pulumi.set(__self__, "reference_schema", reference_schema)
        if s3_reference_data_source is not None:
            pulumi.set(__self__, "s3_reference_data_source", s3_reference_data_source)
        if table_name is not None:
            pulumi.set(__self__, "table_name", table_name)

    @property
    @pulumi.getter(name="referenceSchema")
    def reference_schema(self) -> 'outputs.ApplicationReferenceDataSourceReferenceSchema':
        return pulumi.get(self, "reference_schema")

    @property
    @pulumi.getter(name="s3ReferenceDataSource")
    def s3_reference_data_source(self) -> Optional['outputs.ApplicationReferenceDataSourceS3ReferenceDataSource']:
        return pulumi.get(self, "s3_reference_data_source")

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


@pulumi.output_type
class ApplicationReferenceDataSourceReferenceSchema(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "recordColumns":
            suggest = "record_columns"
        elif key == "recordFormat":
            suggest = "record_format"
        elif key == "recordEncoding":
            suggest = "record_encoding"

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

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

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

    def __init__(__self__, *,
                 record_columns: Sequence['outputs.ApplicationReferenceDataSourceRecordColumn'],
                 record_format: 'outputs.ApplicationReferenceDataSourceRecordFormat',
                 record_encoding: Optional[str] = None):
        pulumi.set(__self__, "record_columns", record_columns)
        pulumi.set(__self__, "record_format", record_format)
        if record_encoding is not None:
            pulumi.set(__self__, "record_encoding", record_encoding)

    @property
    @pulumi.getter(name="recordColumns")
    def record_columns(self) -> Sequence['outputs.ApplicationReferenceDataSourceRecordColumn']:
        return pulumi.get(self, "record_columns")

    @property
    @pulumi.getter(name="recordFormat")
    def record_format(self) -> 'outputs.ApplicationReferenceDataSourceRecordFormat':
        return pulumi.get(self, "record_format")

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


@pulumi.output_type
class ApplicationReferenceDataSourceS3ReferenceDataSource(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bucketARN":
            suggest = "bucket_arn"
        elif key == "fileKey":
            suggest = "file_key"
        elif key == "referenceRoleARN":
            suggest = "reference_role_arn"

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

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

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

    def __init__(__self__, *,
                 bucket_arn: str,
                 file_key: str,
                 reference_role_arn: str):
        pulumi.set(__self__, "bucket_arn", bucket_arn)
        pulumi.set(__self__, "file_key", file_key)
        pulumi.set(__self__, "reference_role_arn", reference_role_arn)

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

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

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


