# 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

__all__ = [
    'ApplicationApplicationCodeConfigurationArgs',
    'ApplicationApplicationConfigurationArgs',
    'ApplicationApplicationSnapshotConfigurationArgs',
    'ApplicationCSVMappingParametersArgs',
    'ApplicationCatalogConfigurationArgs',
    'ApplicationCheckpointConfigurationArgs',
    'ApplicationCloudWatchLoggingOptionCloudWatchLoggingOptionArgs',
    'ApplicationCodeContentArgs',
    'ApplicationCustomArtifactsConfigurationArgs',
    'ApplicationDeployAsApplicationConfigurationArgs',
    'ApplicationEnvironmentPropertiesArgs',
    'ApplicationFlinkApplicationConfigurationArgs',
    'ApplicationGlueDataCatalogConfigurationArgs',
    'ApplicationInputLambdaProcessorArgs',
    'ApplicationInputParallelismArgs',
    'ApplicationInputProcessingConfigurationArgs',
    'ApplicationInputSchemaArgs',
    'ApplicationInputArgs',
    'ApplicationJSONMappingParametersArgs',
    'ApplicationKinesisFirehoseInputArgs',
    'ApplicationKinesisStreamsInputArgs',
    'ApplicationMappingParametersArgs',
    'ApplicationMonitoringConfigurationArgs',
    'ApplicationOutputResourceDestinationSchemaArgs',
    'ApplicationOutputResourceKinesisFirehoseOutputArgs',
    'ApplicationOutputResourceKinesisStreamsOutputArgs',
    'ApplicationOutputResourceLambdaOutputArgs',
    'ApplicationOutputResourceOutputArgs',
    'ApplicationParallelismConfigurationArgs',
    'ApplicationPropertyGroupArgs',
    'ApplicationRecordColumnArgs',
    'ApplicationRecordFormatArgs',
    'ApplicationReferenceDataSourceCSVMappingParametersArgs',
    'ApplicationReferenceDataSourceJSONMappingParametersArgs',
    'ApplicationReferenceDataSourceMappingParametersArgs',
    'ApplicationReferenceDataSourceRecordColumnArgs',
    'ApplicationReferenceDataSourceRecordFormatArgs',
    'ApplicationReferenceDataSourceReferenceDataSourceArgs',
    'ApplicationReferenceDataSourceReferenceSchemaArgs',
    'ApplicationReferenceDataSourceS3ReferenceDataSourceArgs',
    'ApplicationS3ContentBaseLocationArgs',
    'ApplicationS3ContentLocationArgs',
    'ApplicationSqlApplicationConfigurationArgs',
    'ApplicationTagArgs',
    'ApplicationZeppelinApplicationConfigurationArgs',
    'ApplicationZeppelinMonitoringConfigurationArgs',
]

@pulumi.input_type
class ApplicationApplicationCodeConfigurationArgs:
    def __init__(__self__, *,
                 code_content: pulumi.Input['ApplicationCodeContentArgs'],
                 code_content_type: pulumi.Input[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) -> pulumi.Input['ApplicationCodeContentArgs']:
        return pulumi.get(self, "code_content")

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

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

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


@pulumi.input_type
class ApplicationApplicationConfigurationArgs:
    def __init__(__self__, *,
                 application_code_configuration: Optional[pulumi.Input['ApplicationApplicationCodeConfigurationArgs']] = None,
                 application_snapshot_configuration: Optional[pulumi.Input['ApplicationApplicationSnapshotConfigurationArgs']] = None,
                 environment_properties: Optional[pulumi.Input['ApplicationEnvironmentPropertiesArgs']] = None,
                 flink_application_configuration: Optional[pulumi.Input['ApplicationFlinkApplicationConfigurationArgs']] = None,
                 sql_application_configuration: Optional[pulumi.Input['ApplicationSqlApplicationConfigurationArgs']] = None,
                 zeppelin_application_configuration: Optional[pulumi.Input['ApplicationZeppelinApplicationConfigurationArgs']] = 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[pulumi.Input['ApplicationApplicationCodeConfigurationArgs']]:
        return pulumi.get(self, "application_code_configuration")

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class ApplicationApplicationSnapshotConfigurationArgs:
    def __init__(__self__, *,
                 snapshots_enabled: pulumi.Input[bool]):
        pulumi.set(__self__, "snapshots_enabled", snapshots_enabled)

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

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


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

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

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

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


@pulumi.input_type
class ApplicationCatalogConfigurationArgs:
    def __init__(__self__, *,
                 glue_data_catalog_configuration: Optional[pulumi.Input['ApplicationGlueDataCatalogConfigurationArgs']] = 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[pulumi.Input['ApplicationGlueDataCatalogConfigurationArgs']]:
        return pulumi.get(self, "glue_data_catalog_configuration")

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


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

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

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

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

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

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

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

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

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


@pulumi.input_type
class ApplicationCloudWatchLoggingOptionCloudWatchLoggingOptionArgs:
    def __init__(__self__, *,
                 log_stream_arn: pulumi.Input[str]):
        pulumi.set(__self__, "log_stream_arn", log_stream_arn)

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

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


@pulumi.input_type
class ApplicationCodeContentArgs:
    def __init__(__self__, *,
                 s3_content_location: Optional[pulumi.Input['ApplicationS3ContentLocationArgs']] = None,
                 text_content: Optional[pulumi.Input[str]] = None,
                 zip_file_content: Optional[pulumi.Input[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[pulumi.Input['ApplicationS3ContentLocationArgs']]:
        return pulumi.get(self, "s3_content_location")

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

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

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

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

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


@pulumi.input_type
class ApplicationCustomArtifactsConfigurationArgs:
    def __init__(__self__):
        pass


@pulumi.input_type
class ApplicationDeployAsApplicationConfigurationArgs:
    def __init__(__self__, *,
                 s3_content_location: pulumi.Input['ApplicationS3ContentBaseLocationArgs']):
        pulumi.set(__self__, "s3_content_location", s3_content_location)

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

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


@pulumi.input_type
class ApplicationEnvironmentPropertiesArgs:
    def __init__(__self__, *,
                 property_groups: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationPropertyGroupArgs']]]] = None):
        if property_groups is not None:
            pulumi.set(__self__, "property_groups", property_groups)

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

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


@pulumi.input_type
class ApplicationFlinkApplicationConfigurationArgs:
    def __init__(__self__, *,
                 checkpoint_configuration: Optional[pulumi.Input['ApplicationCheckpointConfigurationArgs']] = None,
                 monitoring_configuration: Optional[pulumi.Input['ApplicationMonitoringConfigurationArgs']] = None,
                 parallelism_configuration: Optional[pulumi.Input['ApplicationParallelismConfigurationArgs']] = 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[pulumi.Input['ApplicationCheckpointConfigurationArgs']]:
        return pulumi.get(self, "checkpoint_configuration")

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

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

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

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

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


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

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


@pulumi.input_type
class ApplicationInputLambdaProcessorArgs:
    def __init__(__self__, *,
                 resource_arn: pulumi.Input[str]):
        pulumi.set(__self__, "resource_arn", resource_arn)

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

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


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

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

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


@pulumi.input_type
class ApplicationInputProcessingConfigurationArgs:
    def __init__(__self__, *,
                 input_lambda_processor: Optional[pulumi.Input['ApplicationInputLambdaProcessorArgs']] = 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[pulumi.Input['ApplicationInputLambdaProcessorArgs']]:
        return pulumi.get(self, "input_lambda_processor")

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


@pulumi.input_type
class ApplicationInputSchemaArgs:
    def __init__(__self__, *,
                 record_columns: pulumi.Input[Sequence[pulumi.Input['ApplicationRecordColumnArgs']]],
                 record_format: pulumi.Input['ApplicationRecordFormatArgs'],
                 record_encoding: Optional[pulumi.Input[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) -> pulumi.Input[Sequence[pulumi.Input['ApplicationRecordColumnArgs']]]:
        return pulumi.get(self, "record_columns")

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

    @property
    @pulumi.getter(name="recordFormat")
    def record_format(self) -> pulumi.Input['ApplicationRecordFormatArgs']:
        return pulumi.get(self, "record_format")

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

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

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


@pulumi.input_type
class ApplicationInputArgs:
    def __init__(__self__, *,
                 input_schema: pulumi.Input['ApplicationInputSchemaArgs'],
                 name_prefix: pulumi.Input[str],
                 input_parallelism: Optional[pulumi.Input['ApplicationInputParallelismArgs']] = None,
                 input_processing_configuration: Optional[pulumi.Input['ApplicationInputProcessingConfigurationArgs']] = None,
                 kinesis_firehose_input: Optional[pulumi.Input['ApplicationKinesisFirehoseInputArgs']] = None,
                 kinesis_streams_input: Optional[pulumi.Input['ApplicationKinesisStreamsInputArgs']] = 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) -> pulumi.Input['ApplicationInputSchemaArgs']:
        return pulumi.get(self, "input_schema")

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class ApplicationJSONMappingParametersArgs:
    def __init__(__self__, *,
                 record_row_path: pulumi.Input[str]):
        pulumi.set(__self__, "record_row_path", record_row_path)

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

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


@pulumi.input_type
class ApplicationKinesisFirehoseInputArgs:
    def __init__(__self__, *,
                 resource_arn: pulumi.Input[str]):
        pulumi.set(__self__, "resource_arn", resource_arn)

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

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


@pulumi.input_type
class ApplicationKinesisStreamsInputArgs:
    def __init__(__self__, *,
                 resource_arn: pulumi.Input[str]):
        pulumi.set(__self__, "resource_arn", resource_arn)

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

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


@pulumi.input_type
class ApplicationMappingParametersArgs:
    def __init__(__self__, *,
                 c_sv_mapping_parameters: Optional[pulumi.Input['ApplicationCSVMappingParametersArgs']] = None,
                 j_son_mapping_parameters: Optional[pulumi.Input['ApplicationJSONMappingParametersArgs']] = 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[pulumi.Input['ApplicationCSVMappingParametersArgs']]:
        return pulumi.get(self, "c_sv_mapping_parameters")

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

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

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


@pulumi.input_type
class ApplicationMonitoringConfigurationArgs:
    def __init__(__self__, *,
                 configuration_type: pulumi.Input[str],
                 log_level: Optional[pulumi.Input[str]] = None,
                 metrics_level: Optional[pulumi.Input[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) -> pulumi.Input[str]:
        return pulumi.get(self, "configuration_type")

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

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

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

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

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


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

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


@pulumi.input_type
class ApplicationOutputResourceKinesisFirehoseOutputArgs:
    def __init__(__self__, *,
                 resource_arn: pulumi.Input[str]):
        pulumi.set(__self__, "resource_arn", resource_arn)

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

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


@pulumi.input_type
class ApplicationOutputResourceKinesisStreamsOutputArgs:
    def __init__(__self__, *,
                 resource_arn: pulumi.Input[str]):
        pulumi.set(__self__, "resource_arn", resource_arn)

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

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


@pulumi.input_type
class ApplicationOutputResourceLambdaOutputArgs:
    def __init__(__self__, *,
                 resource_arn: pulumi.Input[str]):
        pulumi.set(__self__, "resource_arn", resource_arn)

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

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


@pulumi.input_type
class ApplicationOutputResourceOutputArgs:
    def __init__(__self__, *,
                 destination_schema: pulumi.Input['ApplicationOutputResourceDestinationSchemaArgs'],
                 kinesis_firehose_output: Optional[pulumi.Input['ApplicationOutputResourceKinesisFirehoseOutputArgs']] = None,
                 kinesis_streams_output: Optional[pulumi.Input['ApplicationOutputResourceKinesisStreamsOutputArgs']] = None,
                 lambda_output: Optional[pulumi.Input['ApplicationOutputResourceLambdaOutputArgs']] = None,
                 name: Optional[pulumi.Input[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) -> pulumi.Input['ApplicationOutputResourceDestinationSchemaArgs']:
        return pulumi.get(self, "destination_schema")

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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


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

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

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

    @property_map.setter
    def property_map(self, value: Optional[Any]):
        pulumi.set(self, "property_map", value)


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

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

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

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

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

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


@pulumi.input_type
class ApplicationRecordFormatArgs:
    def __init__(__self__, *,
                 record_format_type: pulumi.Input[str],
                 mapping_parameters: Optional[pulumi.Input['ApplicationMappingParametersArgs']] = 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) -> pulumi.Input[str]:
        return pulumi.get(self, "record_format_type")

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

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

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


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

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

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

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


@pulumi.input_type
class ApplicationReferenceDataSourceJSONMappingParametersArgs:
    def __init__(__self__, *,
                 record_row_path: pulumi.Input[str]):
        pulumi.set(__self__, "record_row_path", record_row_path)

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

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


@pulumi.input_type
class ApplicationReferenceDataSourceMappingParametersArgs:
    def __init__(__self__, *,
                 c_sv_mapping_parameters: Optional[pulumi.Input['ApplicationReferenceDataSourceCSVMappingParametersArgs']] = None,
                 j_son_mapping_parameters: Optional[pulumi.Input['ApplicationReferenceDataSourceJSONMappingParametersArgs']] = 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[pulumi.Input['ApplicationReferenceDataSourceCSVMappingParametersArgs']]:
        return pulumi.get(self, "c_sv_mapping_parameters")

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

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

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


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

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

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

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

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

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


@pulumi.input_type
class ApplicationReferenceDataSourceRecordFormatArgs:
    def __init__(__self__, *,
                 record_format_type: pulumi.Input[str],
                 mapping_parameters: Optional[pulumi.Input['ApplicationReferenceDataSourceMappingParametersArgs']] = 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) -> pulumi.Input[str]:
        return pulumi.get(self, "record_format_type")

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

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

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


@pulumi.input_type
class ApplicationReferenceDataSourceReferenceDataSourceArgs:
    def __init__(__self__, *,
                 reference_schema: pulumi.Input['ApplicationReferenceDataSourceReferenceSchemaArgs'],
                 s3_reference_data_source: Optional[pulumi.Input['ApplicationReferenceDataSourceS3ReferenceDataSourceArgs']] = None,
                 table_name: Optional[pulumi.Input[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) -> pulumi.Input['ApplicationReferenceDataSourceReferenceSchemaArgs']:
        return pulumi.get(self, "reference_schema")

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

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

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

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

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


@pulumi.input_type
class ApplicationReferenceDataSourceReferenceSchemaArgs:
    def __init__(__self__, *,
                 record_columns: pulumi.Input[Sequence[pulumi.Input['ApplicationReferenceDataSourceRecordColumnArgs']]],
                 record_format: pulumi.Input['ApplicationReferenceDataSourceRecordFormatArgs'],
                 record_encoding: Optional[pulumi.Input[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) -> pulumi.Input[Sequence[pulumi.Input['ApplicationReferenceDataSourceRecordColumnArgs']]]:
        return pulumi.get(self, "record_columns")

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

    @property
    @pulumi.getter(name="recordFormat")
    def record_format(self) -> pulumi.Input['ApplicationReferenceDataSourceRecordFormatArgs']:
        return pulumi.get(self, "record_format")

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

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

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


@pulumi.input_type
class ApplicationReferenceDataSourceS3ReferenceDataSourceArgs:
    def __init__(__self__, *,
                 bucket_arn: pulumi.Input[str],
                 file_key: pulumi.Input[str]):
        pulumi.set(__self__, "bucket_arn", bucket_arn)
        pulumi.set(__self__, "file_key", file_key)

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

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

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

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


@pulumi.input_type
class ApplicationS3ContentBaseLocationArgs:
    def __init__(__self__, *,
                 base_path: pulumi.Input[str],
                 bucket_arn: pulumi.Input[str]):
        pulumi.set(__self__, "base_path", base_path)
        pulumi.set(__self__, "bucket_arn", bucket_arn)

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

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

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

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


@pulumi.input_type
class ApplicationS3ContentLocationArgs:
    def __init__(__self__, *,
                 bucket_arn: Optional[pulumi.Input[str]] = None,
                 file_key: Optional[pulumi.Input[str]] = None,
                 object_version: Optional[pulumi.Input[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[pulumi.Input[str]]:
        return pulumi.get(self, "bucket_arn")

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

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

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

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

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


@pulumi.input_type
class ApplicationSqlApplicationConfigurationArgs:
    def __init__(__self__, *,
                 inputs: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationInputArgs']]]] = None):
        if inputs is not None:
            pulumi.set(__self__, "inputs", inputs)

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

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


@pulumi.input_type
class ApplicationTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

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

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

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


@pulumi.input_type
class ApplicationZeppelinApplicationConfigurationArgs:
    def __init__(__self__, *,
                 catalog_configuration: Optional[pulumi.Input['ApplicationCatalogConfigurationArgs']] = None,
                 custom_artifacts_configuration: Optional[pulumi.Input['ApplicationCustomArtifactsConfigurationArgs']] = None,
                 deploy_as_application_configuration: Optional[pulumi.Input['ApplicationDeployAsApplicationConfigurationArgs']] = None,
                 monitoring_configuration: Optional[pulumi.Input['ApplicationZeppelinMonitoringConfigurationArgs']] = 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[pulumi.Input['ApplicationCatalogConfigurationArgs']]:
        return pulumi.get(self, "catalog_configuration")

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

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

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

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

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

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

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


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

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


