# 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__ = [
    'ApplicationApplicationCodeConfiguration',
    'ApplicationApplicationConfiguration',
    'ApplicationApplicationSnapshotConfiguration',
    'ApplicationCSVMappingParameters',
    'ApplicationCatalogConfiguration',
    'ApplicationCheckpointConfiguration',
    'ApplicationCloudWatchLoggingOptionCloudWatchLoggingOption',
    'ApplicationCodeContent',
    'ApplicationCustomArtifactsConfiguration',
    'ApplicationDeployAsApplicationConfiguration',
    'ApplicationEnvironmentProperties',
    'ApplicationFlinkApplicationConfiguration',
    'ApplicationGlueDataCatalogConfiguration',
    'ApplicationInput',
    'ApplicationInputLambdaProcessor',
    'ApplicationInputParallelism',
    'ApplicationInputProcessingConfiguration',
    'ApplicationInputSchema',
    'ApplicationJSONMappingParameters',
    'ApplicationKinesisFirehoseInput',
    'ApplicationKinesisStreamsInput',
    'ApplicationMappingParameters',
    'ApplicationMonitoringConfiguration',
    'ApplicationOutputResourceDestinationSchema',
    'ApplicationOutputResourceKinesisFirehoseOutput',
    'ApplicationOutputResourceKinesisStreamsOutput',
    'ApplicationOutputResourceLambdaOutput',
    'ApplicationOutputResourceOutput',
    'ApplicationParallelismConfiguration',
    'ApplicationPropertyGroup',
    'ApplicationRecordColumn',
    'ApplicationRecordFormat',
    'ApplicationReferenceDataSourceCSVMappingParameters',
    'ApplicationReferenceDataSourceJSONMappingParameters',
    'ApplicationReferenceDataSourceMappingParameters',
    'ApplicationReferenceDataSourceRecordColumn',
    'ApplicationReferenceDataSourceRecordFormat',
    'ApplicationReferenceDataSourceReferenceDataSource',
    'ApplicationReferenceDataSourceReferenceSchema',
    'ApplicationReferenceDataSourceS3ReferenceDataSource',
    'ApplicationS3ContentBaseLocation',
    'ApplicationS3ContentLocation',
    'ApplicationSqlApplicationConfiguration',
    'ApplicationTag',
    'ApplicationZeppelinApplicationConfiguration',
    'ApplicationZeppelinMonitoringConfiguration',
]

@pulumi.output_type
class ApplicationApplicationCodeConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "codeContent":
            suggest = "code_content"
        elif key == "codeContentType":
            suggest = "code_content_type"

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

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

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

    def __init__(__self__, *,
                 code_content: 'outputs.ApplicationCodeContent',
                 code_content_type: str):
        pulumi.set(__self__, "code_content", code_content)
        pulumi.set(__self__, "code_content_type", code_content_type)

    @property
    @pulumi.getter(name="codeContent")
    def code_content(self) -> 'outputs.ApplicationCodeContent':
        return pulumi.get(self, "code_content")

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


@pulumi.output_type
class ApplicationApplicationConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "applicationCodeConfiguration":
            suggest = "application_code_configuration"
        elif key == "applicationSnapshotConfiguration":
            suggest = "application_snapshot_configuration"
        elif key == "environmentProperties":
            suggest = "environment_properties"
        elif key == "flinkApplicationConfiguration":
            suggest = "flink_application_configuration"
        elif key == "sqlApplicationConfiguration":
            suggest = "sql_application_configuration"
        elif key == "zeppelinApplicationConfiguration":
            suggest = "zeppelin_application_configuration"

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

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

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

    def __init__(__self__, *,
                 application_code_configuration: Optional['outputs.ApplicationApplicationCodeConfiguration'] = None,
                 application_snapshot_configuration: Optional['outputs.ApplicationApplicationSnapshotConfiguration'] = None,
                 environment_properties: Optional['outputs.ApplicationEnvironmentProperties'] = None,
                 flink_application_configuration: Optional['outputs.ApplicationFlinkApplicationConfiguration'] = None,
                 sql_application_configuration: Optional['outputs.ApplicationSqlApplicationConfiguration'] = None,
                 zeppelin_application_configuration: Optional['outputs.ApplicationZeppelinApplicationConfiguration'] = None):
        if application_code_configuration is not None:
            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 zeppelin_application_configuration is not None:
            pulumi.set(__self__, "zeppelin_application_configuration", zeppelin_application_configuration)

    @property
    @pulumi.getter(name="applicationCodeConfiguration")
    def application_code_configuration(self) -> Optional['outputs.ApplicationApplicationCodeConfiguration']:
        return pulumi.get(self, "application_code_configuration")

    @property
    @pulumi.getter(name="applicationSnapshotConfiguration")
    def application_snapshot_configuration(self) -> Optional['outputs.ApplicationApplicationSnapshotConfiguration']:
        return pulumi.get(self, "application_snapshot_configuration")

    @property
    @pulumi.getter(name="environmentProperties")
    def environment_properties(self) -> Optional['outputs.ApplicationEnvironmentProperties']:
        return pulumi.get(self, "environment_properties")

    @property
    @pulumi.getter(name="flinkApplicationConfiguration")
    def flink_application_configuration(self) -> Optional['outputs.ApplicationFlinkApplicationConfiguration']:
        return pulumi.get(self, "flink_application_configuration")

    @property
    @pulumi.getter(name="sqlApplicationConfiguration")
    def sql_application_configuration(self) -> Optional['outputs.ApplicationSqlApplicationConfiguration']:
        return pulumi.get(self, "sql_application_configuration")

    @property
    @pulumi.getter(name="zeppelinApplicationConfiguration")
    def zeppelin_application_configuration(self) -> Optional['outputs.ApplicationZeppelinApplicationConfiguration']:
        return pulumi.get(self, "zeppelin_application_configuration")


@pulumi.output_type
class ApplicationApplicationSnapshotConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "snapshotsEnabled":
            suggest = "snapshots_enabled"

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

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

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

    def __init__(__self__, *,
                 snapshots_enabled: bool):
        pulumi.set(__self__, "snapshots_enabled", snapshots_enabled)

    @property
    @pulumi.getter(name="snapshotsEnabled")
    def snapshots_enabled(self) -> bool:
        return pulumi.get(self, "snapshots_enabled")


@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 ApplicationCatalogConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "glueDataCatalogConfiguration":
            suggest = "glue_data_catalog_configuration"

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

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

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

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

    @property
    @pulumi.getter(name="glueDataCatalogConfiguration")
    def glue_data_catalog_configuration(self) -> Optional['outputs.ApplicationGlueDataCatalogConfiguration']:
        return pulumi.get(self, "glue_data_catalog_configuration")


@pulumi.output_type
class ApplicationCheckpointConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "configurationType":
            suggest = "configuration_type"
        elif key == "checkpointInterval":
            suggest = "checkpoint_interval"
        elif key == "checkpointingEnabled":
            suggest = "checkpointing_enabled"
        elif key == "minPauseBetweenCheckpoints":
            suggest = "min_pause_between_checkpoints"

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

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

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

    def __init__(__self__, *,
                 configuration_type: str,
                 checkpoint_interval: Optional[int] = None,
                 checkpointing_enabled: Optional[bool] = None,
                 min_pause_between_checkpoints: Optional[int] = None):
        pulumi.set(__self__, "configuration_type", configuration_type)
        if checkpoint_interval is not None:
            pulumi.set(__self__, "checkpoint_interval", checkpoint_interval)
        if checkpointing_enabled is not None:
            pulumi.set(__self__, "checkpointing_enabled", checkpointing_enabled)
        if min_pause_between_checkpoints is not None:
            pulumi.set(__self__, "min_pause_between_checkpoints", min_pause_between_checkpoints)

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

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

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

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


@pulumi.output_type
class ApplicationCloudWatchLoggingOptionCloudWatchLoggingOption(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "logStreamARN":
            suggest = "log_stream_arn"

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

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

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

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

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


@pulumi.output_type
class ApplicationCodeContent(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "s3ContentLocation":
            suggest = "s3_content_location"
        elif key == "textContent":
            suggest = "text_content"
        elif key == "zipFileContent":
            suggest = "zip_file_content"

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

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

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

    def __init__(__self__, *,
                 s3_content_location: Optional['outputs.ApplicationS3ContentLocation'] = None,
                 text_content: Optional[str] = None,
                 zip_file_content: Optional[str] = None):
        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)
        if zip_file_content is not None:
            pulumi.set(__self__, "zip_file_content", zip_file_content)

    @property
    @pulumi.getter(name="s3ContentLocation")
    def s3_content_location(self) -> Optional['outputs.ApplicationS3ContentLocation']:
        return pulumi.get(self, "s3_content_location")

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

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


@pulumi.output_type
class ApplicationCustomArtifactsConfiguration(dict):
    def __init__(__self__):
        pass


@pulumi.output_type
class ApplicationDeployAsApplicationConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "s3ContentLocation":
            suggest = "s3_content_location"

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

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

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

    def __init__(__self__, *,
                 s3_content_location: 'outputs.ApplicationS3ContentBaseLocation'):
        pulumi.set(__self__, "s3_content_location", s3_content_location)

    @property
    @pulumi.getter(name="s3ContentLocation")
    def s3_content_location(self) -> 'outputs.ApplicationS3ContentBaseLocation':
        return pulumi.get(self, "s3_content_location")


@pulumi.output_type
class ApplicationEnvironmentProperties(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "propertyGroups":
            suggest = "property_groups"

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

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

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

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

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


@pulumi.output_type
class ApplicationFlinkApplicationConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "checkpointConfiguration":
            suggest = "checkpoint_configuration"
        elif key == "monitoringConfiguration":
            suggest = "monitoring_configuration"
        elif key == "parallelismConfiguration":
            suggest = "parallelism_configuration"

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

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

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

    def __init__(__self__, *,
                 checkpoint_configuration: Optional['outputs.ApplicationCheckpointConfiguration'] = None,
                 monitoring_configuration: Optional['outputs.ApplicationMonitoringConfiguration'] = None,
                 parallelism_configuration: Optional['outputs.ApplicationParallelismConfiguration'] = None):
        if checkpoint_configuration is not None:
            pulumi.set(__self__, "checkpoint_configuration", checkpoint_configuration)
        if monitoring_configuration is not None:
            pulumi.set(__self__, "monitoring_configuration", monitoring_configuration)
        if parallelism_configuration is not None:
            pulumi.set(__self__, "parallelism_configuration", parallelism_configuration)

    @property
    @pulumi.getter(name="checkpointConfiguration")
    def checkpoint_configuration(self) -> Optional['outputs.ApplicationCheckpointConfiguration']:
        return pulumi.get(self, "checkpoint_configuration")

    @property
    @pulumi.getter(name="monitoringConfiguration")
    def monitoring_configuration(self) -> Optional['outputs.ApplicationMonitoringConfiguration']:
        return pulumi.get(self, "monitoring_configuration")

    @property
    @pulumi.getter(name="parallelismConfiguration")
    def parallelism_configuration(self) -> Optional['outputs.ApplicationParallelismConfiguration']:
        return pulumi.get(self, "parallelism_configuration")


@pulumi.output_type
class ApplicationGlueDataCatalogConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseARN":
            suggest = "database_arn"

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

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

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

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

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


@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"

        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):
        pulumi.set(__self__, "resource_arn", resource_arn)

    @property
    @pulumi.getter(name="resourceARN")
    def resource_arn(self) -> str:
        return pulumi.get(self, "resource_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"

        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):
        pulumi.set(__self__, "resource_arn", resource_arn)

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


@pulumi.output_type
class ApplicationKinesisStreamsInput(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resourceARN":
            suggest = "resource_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):
        pulumi.set(__self__, "resource_arn", resource_arn)

    @property
    @pulumi.getter(name="resourceARN")
    def resource_arn(self) -> str:
        return pulumi.get(self, "resource_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 ApplicationMonitoringConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "configurationType":
            suggest = "configuration_type"
        elif key == "logLevel":
            suggest = "log_level"
        elif key == "metricsLevel":
            suggest = "metrics_level"

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

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

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

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

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

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

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


@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"

        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):
        pulumi.set(__self__, "resource_arn", resource_arn)

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


@pulumi.output_type
class ApplicationOutputResourceKinesisStreamsOutput(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resourceARN":
            suggest = "resource_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):
        pulumi.set(__self__, "resource_arn", resource_arn)

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


@pulumi.output_type
class ApplicationOutputResourceLambdaOutput(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resourceARN":
            suggest = "resource_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):
        pulumi.set(__self__, "resource_arn", resource_arn)

    @property
    @pulumi.getter(name="resourceARN")
    def resource_arn(self) -> str:
        return pulumi.get(self, "resource_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 ApplicationParallelismConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "configurationType":
            suggest = "configuration_type"
        elif key == "autoScalingEnabled":
            suggest = "auto_scaling_enabled"
        elif key == "parallelismPerKPU":
            suggest = "parallelism_per_kpu"

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

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

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

    def __init__(__self__, *,
                 configuration_type: str,
                 auto_scaling_enabled: Optional[bool] = None,
                 parallelism: Optional[int] = None,
                 parallelism_per_kpu: Optional[int] = None):
        pulumi.set(__self__, "configuration_type", configuration_type)
        if auto_scaling_enabled is not None:
            pulumi.set(__self__, "auto_scaling_enabled", auto_scaling_enabled)
        if parallelism is not None:
            pulumi.set(__self__, "parallelism", parallelism)
        if parallelism_per_kpu is not None:
            pulumi.set(__self__, "parallelism_per_kpu", parallelism_per_kpu)

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

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

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

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


@pulumi.output_type
class ApplicationPropertyGroup(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "propertyGroupId":
            suggest = "property_group_id"
        elif key == "propertyMap":
            suggest = "property_map"

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

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

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

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

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

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


@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"

        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):
        pulumi.set(__self__, "bucket_arn", bucket_arn)
        pulumi.set(__self__, "file_key", file_key)

    @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")


@pulumi.output_type
class ApplicationS3ContentBaseLocation(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "basePath":
            suggest = "base_path"
        elif key == "bucketARN":
            suggest = "bucket_arn"

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

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

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

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 bucket_arn: Optional[str] = None,
                 file_key: Optional[str] = None,
                 object_version: Optional[str] = None):
        if bucket_arn is not None:
            pulumi.set(__self__, "bucket_arn", bucket_arn)
        if file_key is not None:
            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) -> Optional[str]:
        return pulumi.get(self, "bucket_arn")

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

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


@pulumi.output_type
class ApplicationSqlApplicationConfiguration(dict):
    def __init__(__self__, *,
                 inputs: Optional[Sequence['outputs.ApplicationInput']] = None):
        if inputs is not None:
            pulumi.set(__self__, "inputs", inputs)

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


@pulumi.output_type
class ApplicationTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

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


@pulumi.output_type
class ApplicationZeppelinApplicationConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "catalogConfiguration":
            suggest = "catalog_configuration"
        elif key == "customArtifactsConfiguration":
            suggest = "custom_artifacts_configuration"
        elif key == "deployAsApplicationConfiguration":
            suggest = "deploy_as_application_configuration"
        elif key == "monitoringConfiguration":
            suggest = "monitoring_configuration"

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

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

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

    def __init__(__self__, *,
                 catalog_configuration: Optional['outputs.ApplicationCatalogConfiguration'] = None,
                 custom_artifacts_configuration: Optional['outputs.ApplicationCustomArtifactsConfiguration'] = None,
                 deploy_as_application_configuration: Optional['outputs.ApplicationDeployAsApplicationConfiguration'] = None,
                 monitoring_configuration: Optional['outputs.ApplicationZeppelinMonitoringConfiguration'] = None):
        if catalog_configuration is not None:
            pulumi.set(__self__, "catalog_configuration", catalog_configuration)
        if custom_artifacts_configuration is not None:
            pulumi.set(__self__, "custom_artifacts_configuration", custom_artifacts_configuration)
        if deploy_as_application_configuration is not None:
            pulumi.set(__self__, "deploy_as_application_configuration", deploy_as_application_configuration)
        if monitoring_configuration is not None:
            pulumi.set(__self__, "monitoring_configuration", monitoring_configuration)

    @property
    @pulumi.getter(name="catalogConfiguration")
    def catalog_configuration(self) -> Optional['outputs.ApplicationCatalogConfiguration']:
        return pulumi.get(self, "catalog_configuration")

    @property
    @pulumi.getter(name="customArtifactsConfiguration")
    def custom_artifacts_configuration(self) -> Optional['outputs.ApplicationCustomArtifactsConfiguration']:
        return pulumi.get(self, "custom_artifacts_configuration")

    @property
    @pulumi.getter(name="deployAsApplicationConfiguration")
    def deploy_as_application_configuration(self) -> Optional['outputs.ApplicationDeployAsApplicationConfiguration']:
        return pulumi.get(self, "deploy_as_application_configuration")

    @property
    @pulumi.getter(name="monitoringConfiguration")
    def monitoring_configuration(self) -> Optional['outputs.ApplicationZeppelinMonitoringConfiguration']:
        return pulumi.get(self, "monitoring_configuration")


@pulumi.output_type
class ApplicationZeppelinMonitoringConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "logLevel":
            suggest = "log_level"

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

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

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

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

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


