# 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 ._enums import *

__all__ = [
    'AlertActionArgs',
    'AlertLambdaConfigurationArgs',
    'AlertSNSConfigurationArgs',
    'AnomalyDetectorAnomalyDetectorConfigArgs',
    'AnomalyDetectorAppFlowConfigArgs',
    'AnomalyDetectorCloudwatchConfigArgs',
    'AnomalyDetectorCsvFormatDescriptorArgs',
    'AnomalyDetectorFileFormatDescriptorArgs',
    'AnomalyDetectorJsonFormatDescriptorArgs',
    'AnomalyDetectorMetricSetArgs',
    'AnomalyDetectorMetricSourceArgs',
    'AnomalyDetectorMetricArgs',
    'AnomalyDetectorRDSSourceConfigArgs',
    'AnomalyDetectorRedshiftSourceConfigArgs',
    'AnomalyDetectorS3SourceConfigArgs',
    'AnomalyDetectorTimestampColumnArgs',
    'AnomalyDetectorVpcConfigurationArgs',
]

@pulumi.input_type
class AlertActionArgs:
    def __init__(__self__, *,
                 lambda_configuration: Optional[pulumi.Input['AlertLambdaConfigurationArgs']] = None,
                 s_ns_configuration: Optional[pulumi.Input['AlertSNSConfigurationArgs']] = None):
        if lambda_configuration is not None:
            pulumi.set(__self__, "lambda_configuration", lambda_configuration)
        if s_ns_configuration is not None:
            pulumi.set(__self__, "s_ns_configuration", s_ns_configuration)

    @property
    @pulumi.getter(name="lambdaConfiguration")
    def lambda_configuration(self) -> Optional[pulumi.Input['AlertLambdaConfigurationArgs']]:
        return pulumi.get(self, "lambda_configuration")

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

    @property
    @pulumi.getter(name="sNSConfiguration")
    def s_ns_configuration(self) -> Optional[pulumi.Input['AlertSNSConfigurationArgs']]:
        return pulumi.get(self, "s_ns_configuration")

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


@pulumi.input_type
class AlertLambdaConfigurationArgs:
    def __init__(__self__, *,
                 lambda_arn: pulumi.Input[str],
                 role_arn: pulumi.Input[str]):
        """
        Configuration options for a Lambda alert action.
        :param pulumi.Input[str] lambda_arn: ARN of a Lambda to send alert notifications to.
        :param pulumi.Input[str] role_arn: ARN of an IAM role that LookoutMetrics should assume to access the Lambda function.
        """
        pulumi.set(__self__, "lambda_arn", lambda_arn)
        pulumi.set(__self__, "role_arn", role_arn)

    @property
    @pulumi.getter(name="lambdaArn")
    def lambda_arn(self) -> pulumi.Input[str]:
        """
        ARN of a Lambda to send alert notifications to.
        """
        return pulumi.get(self, "lambda_arn")

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

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> pulumi.Input[str]:
        """
        ARN of an IAM role that LookoutMetrics should assume to access the Lambda function.
        """
        return pulumi.get(self, "role_arn")

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


@pulumi.input_type
class AlertSNSConfigurationArgs:
    def __init__(__self__, *,
                 role_arn: pulumi.Input[str],
                 sns_topic_arn: pulumi.Input[str]):
        """
        Configuration options for an SNS alert action.
        :param pulumi.Input[str] role_arn: ARN of an IAM role that LookoutMetrics should assume to access the SNS topic.
        :param pulumi.Input[str] sns_topic_arn: ARN of an SNS topic to send alert notifications to.
        """
        pulumi.set(__self__, "role_arn", role_arn)
        pulumi.set(__self__, "sns_topic_arn", sns_topic_arn)

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> pulumi.Input[str]:
        """
        ARN of an IAM role that LookoutMetrics should assume to access the SNS topic.
        """
        return pulumi.get(self, "role_arn")

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

    @property
    @pulumi.getter(name="snsTopicArn")
    def sns_topic_arn(self) -> pulumi.Input[str]:
        """
        ARN of an SNS topic to send alert notifications to.
        """
        return pulumi.get(self, "sns_topic_arn")

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


@pulumi.input_type
class AnomalyDetectorAnomalyDetectorConfigArgs:
    def __init__(__self__, *,
                 anomaly_detector_frequency: pulumi.Input['AnomalyDetectorAnomalyDetectorFrequency']):
        """
        :param pulumi.Input['AnomalyDetectorAnomalyDetectorFrequency'] anomaly_detector_frequency: Frequency of anomaly detection
        """
        pulumi.set(__self__, "anomaly_detector_frequency", anomaly_detector_frequency)

    @property
    @pulumi.getter(name="anomalyDetectorFrequency")
    def anomaly_detector_frequency(self) -> pulumi.Input['AnomalyDetectorAnomalyDetectorFrequency']:
        """
        Frequency of anomaly detection
        """
        return pulumi.get(self, "anomaly_detector_frequency")

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


@pulumi.input_type
class AnomalyDetectorAppFlowConfigArgs:
    def __init__(__self__, *,
                 flow_name: pulumi.Input[str],
                 role_arn: pulumi.Input[str]):
        pulumi.set(__self__, "flow_name", flow_name)
        pulumi.set(__self__, "role_arn", role_arn)

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

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

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

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


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

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

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


@pulumi.input_type
class AnomalyDetectorCsvFormatDescriptorArgs:
    def __init__(__self__, *,
                 charset: Optional[pulumi.Input[str]] = None,
                 contains_header: Optional[pulumi.Input[bool]] = None,
                 delimiter: Optional[pulumi.Input[str]] = None,
                 file_compression: Optional[pulumi.Input['AnomalyDetectorCsvFormatDescriptorFileCompression']] = None,
                 header_list: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 quote_symbol: Optional[pulumi.Input[str]] = None):
        if charset is not None:
            pulumi.set(__self__, "charset", charset)
        if contains_header is not None:
            pulumi.set(__self__, "contains_header", contains_header)
        if delimiter is not None:
            pulumi.set(__self__, "delimiter", delimiter)
        if file_compression is not None:
            pulumi.set(__self__, "file_compression", file_compression)
        if header_list is not None:
            pulumi.set(__self__, "header_list", header_list)
        if quote_symbol is not None:
            pulumi.set(__self__, "quote_symbol", quote_symbol)

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

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

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

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

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

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

    @property
    @pulumi.getter(name="fileCompression")
    def file_compression(self) -> Optional[pulumi.Input['AnomalyDetectorCsvFormatDescriptorFileCompression']]:
        return pulumi.get(self, "file_compression")

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

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

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

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

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


@pulumi.input_type
class AnomalyDetectorFileFormatDescriptorArgs:
    def __init__(__self__, *,
                 csv_format_descriptor: Optional[pulumi.Input['AnomalyDetectorCsvFormatDescriptorArgs']] = None,
                 json_format_descriptor: Optional[pulumi.Input['AnomalyDetectorJsonFormatDescriptorArgs']] = None):
        if csv_format_descriptor is not None:
            pulumi.set(__self__, "csv_format_descriptor", csv_format_descriptor)
        if json_format_descriptor is not None:
            pulumi.set(__self__, "json_format_descriptor", json_format_descriptor)

    @property
    @pulumi.getter(name="csvFormatDescriptor")
    def csv_format_descriptor(self) -> Optional[pulumi.Input['AnomalyDetectorCsvFormatDescriptorArgs']]:
        return pulumi.get(self, "csv_format_descriptor")

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

    @property
    @pulumi.getter(name="jsonFormatDescriptor")
    def json_format_descriptor(self) -> Optional[pulumi.Input['AnomalyDetectorJsonFormatDescriptorArgs']]:
        return pulumi.get(self, "json_format_descriptor")

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


@pulumi.input_type
class AnomalyDetectorJsonFormatDescriptorArgs:
    def __init__(__self__, *,
                 charset: Optional[pulumi.Input[str]] = None,
                 file_compression: Optional[pulumi.Input['AnomalyDetectorJsonFormatDescriptorFileCompression']] = None):
        if charset is not None:
            pulumi.set(__self__, "charset", charset)
        if file_compression is not None:
            pulumi.set(__self__, "file_compression", file_compression)

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

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

    @property
    @pulumi.getter(name="fileCompression")
    def file_compression(self) -> Optional[pulumi.Input['AnomalyDetectorJsonFormatDescriptorFileCompression']]:
        return pulumi.get(self, "file_compression")

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


@pulumi.input_type
class AnomalyDetectorMetricSetArgs:
    def __init__(__self__, *,
                 metric_list: pulumi.Input[Sequence[pulumi.Input['AnomalyDetectorMetricArgs']]],
                 metric_set_name: pulumi.Input[str],
                 metric_source: pulumi.Input['AnomalyDetectorMetricSourceArgs'],
                 dimension_list: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 metric_set_description: Optional[pulumi.Input[str]] = None,
                 metric_set_frequency: Optional[pulumi.Input['AnomalyDetectorMetricSetMetricSetFrequency']] = None,
                 offset: Optional[pulumi.Input[int]] = None,
                 timestamp_column: Optional[pulumi.Input['AnomalyDetectorTimestampColumnArgs']] = None,
                 timezone: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['AnomalyDetectorMetricArgs']]] metric_list: Metrics captured by this MetricSet.
        :param pulumi.Input[str] metric_set_name: The name of the MetricSet.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] dimension_list: Dimensions for this MetricSet.
        :param pulumi.Input[str] metric_set_description: A description for the MetricSet.
        :param pulumi.Input['AnomalyDetectorMetricSetMetricSetFrequency'] metric_set_frequency: A frequency period to aggregate the data
        :param pulumi.Input[int] offset: Offset, in seconds, between the frequency interval and the time at which the metrics are available.
        """
        pulumi.set(__self__, "metric_list", metric_list)
        pulumi.set(__self__, "metric_set_name", metric_set_name)
        pulumi.set(__self__, "metric_source", metric_source)
        if dimension_list is not None:
            pulumi.set(__self__, "dimension_list", dimension_list)
        if metric_set_description is not None:
            pulumi.set(__self__, "metric_set_description", metric_set_description)
        if metric_set_frequency is not None:
            pulumi.set(__self__, "metric_set_frequency", metric_set_frequency)
        if offset is not None:
            pulumi.set(__self__, "offset", offset)
        if timestamp_column is not None:
            pulumi.set(__self__, "timestamp_column", timestamp_column)
        if timezone is not None:
            pulumi.set(__self__, "timezone", timezone)

    @property
    @pulumi.getter(name="metricList")
    def metric_list(self) -> pulumi.Input[Sequence[pulumi.Input['AnomalyDetectorMetricArgs']]]:
        """
        Metrics captured by this MetricSet.
        """
        return pulumi.get(self, "metric_list")

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

    @property
    @pulumi.getter(name="metricSetName")
    def metric_set_name(self) -> pulumi.Input[str]:
        """
        The name of the MetricSet.
        """
        return pulumi.get(self, "metric_set_name")

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

    @property
    @pulumi.getter(name="metricSource")
    def metric_source(self) -> pulumi.Input['AnomalyDetectorMetricSourceArgs']:
        return pulumi.get(self, "metric_source")

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

    @property
    @pulumi.getter(name="dimensionList")
    def dimension_list(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Dimensions for this MetricSet.
        """
        return pulumi.get(self, "dimension_list")

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

    @property
    @pulumi.getter(name="metricSetDescription")
    def metric_set_description(self) -> Optional[pulumi.Input[str]]:
        """
        A description for the MetricSet.
        """
        return pulumi.get(self, "metric_set_description")

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

    @property
    @pulumi.getter(name="metricSetFrequency")
    def metric_set_frequency(self) -> Optional[pulumi.Input['AnomalyDetectorMetricSetMetricSetFrequency']]:
        """
        A frequency period to aggregate the data
        """
        return pulumi.get(self, "metric_set_frequency")

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

    @property
    @pulumi.getter
    def offset(self) -> Optional[pulumi.Input[int]]:
        """
        Offset, in seconds, between the frequency interval and the time at which the metrics are available.
        """
        return pulumi.get(self, "offset")

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

    @property
    @pulumi.getter(name="timestampColumn")
    def timestamp_column(self) -> Optional[pulumi.Input['AnomalyDetectorTimestampColumnArgs']]:
        return pulumi.get(self, "timestamp_column")

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

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

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


@pulumi.input_type
class AnomalyDetectorMetricSourceArgs:
    def __init__(__self__, *,
                 app_flow_config: Optional[pulumi.Input['AnomalyDetectorAppFlowConfigArgs']] = None,
                 cloudwatch_config: Optional[pulumi.Input['AnomalyDetectorCloudwatchConfigArgs']] = None,
                 r_ds_source_config: Optional[pulumi.Input['AnomalyDetectorRDSSourceConfigArgs']] = None,
                 redshift_source_config: Optional[pulumi.Input['AnomalyDetectorRedshiftSourceConfigArgs']] = None,
                 s3_source_config: Optional[pulumi.Input['AnomalyDetectorS3SourceConfigArgs']] = None):
        if app_flow_config is not None:
            pulumi.set(__self__, "app_flow_config", app_flow_config)
        if cloudwatch_config is not None:
            pulumi.set(__self__, "cloudwatch_config", cloudwatch_config)
        if r_ds_source_config is not None:
            pulumi.set(__self__, "r_ds_source_config", r_ds_source_config)
        if redshift_source_config is not None:
            pulumi.set(__self__, "redshift_source_config", redshift_source_config)
        if s3_source_config is not None:
            pulumi.set(__self__, "s3_source_config", s3_source_config)

    @property
    @pulumi.getter(name="appFlowConfig")
    def app_flow_config(self) -> Optional[pulumi.Input['AnomalyDetectorAppFlowConfigArgs']]:
        return pulumi.get(self, "app_flow_config")

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

    @property
    @pulumi.getter(name="cloudwatchConfig")
    def cloudwatch_config(self) -> Optional[pulumi.Input['AnomalyDetectorCloudwatchConfigArgs']]:
        return pulumi.get(self, "cloudwatch_config")

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

    @property
    @pulumi.getter(name="rDSSourceConfig")
    def r_ds_source_config(self) -> Optional[pulumi.Input['AnomalyDetectorRDSSourceConfigArgs']]:
        return pulumi.get(self, "r_ds_source_config")

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

    @property
    @pulumi.getter(name="redshiftSourceConfig")
    def redshift_source_config(self) -> Optional[pulumi.Input['AnomalyDetectorRedshiftSourceConfigArgs']]:
        return pulumi.get(self, "redshift_source_config")

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

    @property
    @pulumi.getter(name="s3SourceConfig")
    def s3_source_config(self) -> Optional[pulumi.Input['AnomalyDetectorS3SourceConfigArgs']]:
        return pulumi.get(self, "s3_source_config")

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


@pulumi.input_type
class AnomalyDetectorMetricArgs:
    def __init__(__self__, *,
                 aggregation_function: pulumi.Input['AnomalyDetectorMetricAggregationFunction'],
                 metric_name: pulumi.Input[str],
                 namespace: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['AnomalyDetectorMetricAggregationFunction'] aggregation_function: Operator used to aggregate metric values
        """
        pulumi.set(__self__, "aggregation_function", aggregation_function)
        pulumi.set(__self__, "metric_name", metric_name)
        if namespace is not None:
            pulumi.set(__self__, "namespace", namespace)

    @property
    @pulumi.getter(name="aggregationFunction")
    def aggregation_function(self) -> pulumi.Input['AnomalyDetectorMetricAggregationFunction']:
        """
        Operator used to aggregate metric values
        """
        return pulumi.get(self, "aggregation_function")

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

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

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

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

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


@pulumi.input_type
class AnomalyDetectorRDSSourceConfigArgs:
    def __init__(__self__, *,
                 d_b_instance_identifier: pulumi.Input[str],
                 database_host: pulumi.Input[str],
                 database_name: pulumi.Input[str],
                 database_port: pulumi.Input[int],
                 role_arn: pulumi.Input[str],
                 secret_manager_arn: pulumi.Input[str],
                 table_name: pulumi.Input[str],
                 vpc_configuration: pulumi.Input['AnomalyDetectorVpcConfigurationArgs']):
        pulumi.set(__self__, "d_b_instance_identifier", d_b_instance_identifier)
        pulumi.set(__self__, "database_host", database_host)
        pulumi.set(__self__, "database_name", database_name)
        pulumi.set(__self__, "database_port", database_port)
        pulumi.set(__self__, "role_arn", role_arn)
        pulumi.set(__self__, "secret_manager_arn", secret_manager_arn)
        pulumi.set(__self__, "table_name", table_name)
        pulumi.set(__self__, "vpc_configuration", vpc_configuration)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="vpcConfiguration")
    def vpc_configuration(self) -> pulumi.Input['AnomalyDetectorVpcConfigurationArgs']:
        return pulumi.get(self, "vpc_configuration")

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


@pulumi.input_type
class AnomalyDetectorRedshiftSourceConfigArgs:
    def __init__(__self__, *,
                 cluster_identifier: pulumi.Input[str],
                 database_host: pulumi.Input[str],
                 database_name: pulumi.Input[str],
                 database_port: pulumi.Input[int],
                 role_arn: pulumi.Input[str],
                 secret_manager_arn: pulumi.Input[str],
                 table_name: pulumi.Input[str],
                 vpc_configuration: pulumi.Input['AnomalyDetectorVpcConfigurationArgs']):
        pulumi.set(__self__, "cluster_identifier", cluster_identifier)
        pulumi.set(__self__, "database_host", database_host)
        pulumi.set(__self__, "database_name", database_name)
        pulumi.set(__self__, "database_port", database_port)
        pulumi.set(__self__, "role_arn", role_arn)
        pulumi.set(__self__, "secret_manager_arn", secret_manager_arn)
        pulumi.set(__self__, "table_name", table_name)
        pulumi.set(__self__, "vpc_configuration", vpc_configuration)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="vpcConfiguration")
    def vpc_configuration(self) -> pulumi.Input['AnomalyDetectorVpcConfigurationArgs']:
        return pulumi.get(self, "vpc_configuration")

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


@pulumi.input_type
class AnomalyDetectorS3SourceConfigArgs:
    def __init__(__self__, *,
                 file_format_descriptor: pulumi.Input['AnomalyDetectorFileFormatDescriptorArgs'],
                 role_arn: pulumi.Input[str],
                 historical_data_path_list: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 templated_path_list: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        pulumi.set(__self__, "file_format_descriptor", file_format_descriptor)
        pulumi.set(__self__, "role_arn", role_arn)
        if historical_data_path_list is not None:
            pulumi.set(__self__, "historical_data_path_list", historical_data_path_list)
        if templated_path_list is not None:
            pulumi.set(__self__, "templated_path_list", templated_path_list)

    @property
    @pulumi.getter(name="fileFormatDescriptor")
    def file_format_descriptor(self) -> pulumi.Input['AnomalyDetectorFileFormatDescriptorArgs']:
        return pulumi.get(self, "file_format_descriptor")

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

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

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

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

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

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

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


@pulumi.input_type
class AnomalyDetectorTimestampColumnArgs:
    def __init__(__self__, *,
                 column_format: Optional[pulumi.Input[str]] = None,
                 column_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] column_format: A timestamp format for the timestamps in the dataset
        """
        if column_format is not None:
            pulumi.set(__self__, "column_format", column_format)
        if column_name is not None:
            pulumi.set(__self__, "column_name", column_name)

    @property
    @pulumi.getter(name="columnFormat")
    def column_format(self) -> Optional[pulumi.Input[str]]:
        """
        A timestamp format for the timestamps in the dataset
        """
        return pulumi.get(self, "column_format")

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

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

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


@pulumi.input_type
class AnomalyDetectorVpcConfigurationArgs:
    def __init__(__self__, *,
                 security_group_id_list: pulumi.Input[Sequence[pulumi.Input[str]]],
                 subnet_id_list: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(__self__, "security_group_id_list", security_group_id_list)
        pulumi.set(__self__, "subnet_id_list", subnet_id_list)

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

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

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

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


