# 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__ = [
    'ChannelChannelStorageArgs',
    'ChannelCustomerManagedS3Args',
    'ChannelRetentionPeriodArgs',
    'ChannelServiceManagedS3Args',
    'ChannelTagArgs',
    'DatasetActionArgs',
    'DatasetContainerActionArgs',
    'DatasetDatasetContentDeliveryRuleDestinationArgs',
    'DatasetDatasetContentDeliveryRuleArgs',
    'DatasetDatasetContentVersionValueArgs',
    'DatasetDeltaTimeSessionWindowConfigurationArgs',
    'DatasetDeltaTimeArgs',
    'DatasetFilterArgs',
    'DatasetGlueConfigurationArgs',
    'DatasetIotEventsDestinationConfigurationArgs',
    'DatasetLateDataRuleConfigurationArgs',
    'DatasetLateDataRuleArgs',
    'DatasetOutputFileUriValueArgs',
    'DatasetQueryActionArgs',
    'DatasetResourceConfigurationArgs',
    'DatasetRetentionPeriodArgs',
    'DatasetS3DestinationConfigurationArgs',
    'DatasetScheduleArgs',
    'DatasetTagArgs',
    'DatasetTriggeringDatasetArgs',
    'DatasetTriggerArgs',
    'DatasetVariableArgs',
    'DatasetVersioningConfigurationArgs',
    'DatastoreColumnArgs',
    'DatastoreCustomerManagedS3StorageArgs',
    'DatastoreCustomerManagedS3Args',
    'DatastoreDatastorePartitionsArgs',
    'DatastoreDatastorePartitionArgs',
    'DatastoreDatastoreStorageArgs',
    'DatastoreFileFormatConfigurationArgs',
    'DatastoreIotSiteWiseMultiLayerStorageArgs',
    'DatastoreJsonConfigurationArgs',
    'DatastoreParquetConfigurationArgs',
    'DatastorePartitionArgs',
    'DatastoreRetentionPeriodArgs',
    'DatastoreSchemaDefinitionArgs',
    'DatastoreServiceManagedS3Args',
    'DatastoreTagArgs',
    'DatastoreTimestampPartitionArgs',
    'PipelineActivityArgs',
    'PipelineAddAttributesArgs',
    'PipelineChannelArgs',
    'PipelineDatastoreArgs',
    'PipelineDeviceRegistryEnrichArgs',
    'PipelineDeviceShadowEnrichArgs',
    'PipelineFilterArgs',
    'PipelineLambdaArgs',
    'PipelineMathArgs',
    'PipelineRemoveAttributesArgs',
    'PipelineSelectAttributesArgs',
    'PipelineTagArgs',
]

@pulumi.input_type
class ChannelChannelStorageArgs:
    def __init__(__self__, *,
                 customer_managed_s3: Optional[pulumi.Input['ChannelCustomerManagedS3Args']] = None,
                 service_managed_s3: Optional[pulumi.Input['ChannelServiceManagedS3Args']] = None):
        if customer_managed_s3 is not None:
            pulumi.set(__self__, "customer_managed_s3", customer_managed_s3)
        if service_managed_s3 is not None:
            pulumi.set(__self__, "service_managed_s3", service_managed_s3)

    @property
    @pulumi.getter(name="customerManagedS3")
    def customer_managed_s3(self) -> Optional[pulumi.Input['ChannelCustomerManagedS3Args']]:
        return pulumi.get(self, "customer_managed_s3")

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

    @property
    @pulumi.getter(name="serviceManagedS3")
    def service_managed_s3(self) -> Optional[pulumi.Input['ChannelServiceManagedS3Args']]:
        return pulumi.get(self, "service_managed_s3")

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


@pulumi.input_type
class ChannelCustomerManagedS3Args:
    def __init__(__self__, *,
                 bucket: pulumi.Input[str],
                 role_arn: pulumi.Input[str],
                 key_prefix: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "bucket", bucket)
        pulumi.set(__self__, "role_arn", role_arn)
        if key_prefix is not None:
            pulumi.set(__self__, "key_prefix", key_prefix)

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

    @bucket.setter
    def bucket(self, value: pulumi.Input[str]):
        pulumi.set(self, "bucket", 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="keyPrefix")
    def key_prefix(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "key_prefix")

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


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

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

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

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

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


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


@pulumi.input_type
class ChannelTagArgs:
    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 DatasetActionArgs:
    def __init__(__self__, *,
                 action_name: pulumi.Input[str],
                 container_action: Optional[pulumi.Input['DatasetContainerActionArgs']] = None,
                 query_action: Optional[pulumi.Input['DatasetQueryActionArgs']] = None):
        pulumi.set(__self__, "action_name", action_name)
        if container_action is not None:
            pulumi.set(__self__, "container_action", container_action)
        if query_action is not None:
            pulumi.set(__self__, "query_action", query_action)

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

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

    @property
    @pulumi.getter(name="containerAction")
    def container_action(self) -> Optional[pulumi.Input['DatasetContainerActionArgs']]:
        return pulumi.get(self, "container_action")

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

    @property
    @pulumi.getter(name="queryAction")
    def query_action(self) -> Optional[pulumi.Input['DatasetQueryActionArgs']]:
        return pulumi.get(self, "query_action")

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


@pulumi.input_type
class DatasetContainerActionArgs:
    def __init__(__self__, *,
                 execution_role_arn: pulumi.Input[str],
                 image: pulumi.Input[str],
                 resource_configuration: pulumi.Input['DatasetResourceConfigurationArgs'],
                 variables: Optional[pulumi.Input[Sequence[pulumi.Input['DatasetVariableArgs']]]] = None):
        pulumi.set(__self__, "execution_role_arn", execution_role_arn)
        pulumi.set(__self__, "image", image)
        pulumi.set(__self__, "resource_configuration", resource_configuration)
        if variables is not None:
            pulumi.set(__self__, "variables", variables)

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

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

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

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

    @property
    @pulumi.getter(name="resourceConfiguration")
    def resource_configuration(self) -> pulumi.Input['DatasetResourceConfigurationArgs']:
        return pulumi.get(self, "resource_configuration")

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

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

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


@pulumi.input_type
class DatasetDatasetContentDeliveryRuleDestinationArgs:
    def __init__(__self__, *,
                 iot_events_destination_configuration: Optional[pulumi.Input['DatasetIotEventsDestinationConfigurationArgs']] = None,
                 s3_destination_configuration: Optional[pulumi.Input['DatasetS3DestinationConfigurationArgs']] = None):
        if iot_events_destination_configuration is not None:
            pulumi.set(__self__, "iot_events_destination_configuration", iot_events_destination_configuration)
        if s3_destination_configuration is not None:
            pulumi.set(__self__, "s3_destination_configuration", s3_destination_configuration)

    @property
    @pulumi.getter(name="iotEventsDestinationConfiguration")
    def iot_events_destination_configuration(self) -> Optional[pulumi.Input['DatasetIotEventsDestinationConfigurationArgs']]:
        return pulumi.get(self, "iot_events_destination_configuration")

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

    @property
    @pulumi.getter(name="s3DestinationConfiguration")
    def s3_destination_configuration(self) -> Optional[pulumi.Input['DatasetS3DestinationConfigurationArgs']]:
        return pulumi.get(self, "s3_destination_configuration")

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


@pulumi.input_type
class DatasetDatasetContentDeliveryRuleArgs:
    def __init__(__self__, *,
                 destination: pulumi.Input['DatasetDatasetContentDeliveryRuleDestinationArgs'],
                 entry_name: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "destination", destination)
        if entry_name is not None:
            pulumi.set(__self__, "entry_name", entry_name)

    @property
    @pulumi.getter
    def destination(self) -> pulumi.Input['DatasetDatasetContentDeliveryRuleDestinationArgs']:
        return pulumi.get(self, "destination")

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

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

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


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

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

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


@pulumi.input_type
class DatasetDeltaTimeSessionWindowConfigurationArgs:
    def __init__(__self__, *,
                 timeout_in_minutes: pulumi.Input[int]):
        pulumi.set(__self__, "timeout_in_minutes", timeout_in_minutes)

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

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


@pulumi.input_type
class DatasetDeltaTimeArgs:
    def __init__(__self__, *,
                 offset_seconds: pulumi.Input[int],
                 time_expression: pulumi.Input[str]):
        pulumi.set(__self__, "offset_seconds", offset_seconds)
        pulumi.set(__self__, "time_expression", time_expression)

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

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

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

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


@pulumi.input_type
class DatasetFilterArgs:
    def __init__(__self__, *,
                 delta_time: Optional[pulumi.Input['DatasetDeltaTimeArgs']] = None):
        if delta_time is not None:
            pulumi.set(__self__, "delta_time", delta_time)

    @property
    @pulumi.getter(name="deltaTime")
    def delta_time(self) -> Optional[pulumi.Input['DatasetDeltaTimeArgs']]:
        return pulumi.get(self, "delta_time")

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


@pulumi.input_type
class DatasetGlueConfigurationArgs:
    def __init__(__self__, *,
                 database_name: pulumi.Input[str],
                 table_name: pulumi.Input[str]):
        pulumi.set(__self__, "database_name", database_name)
        pulumi.set(__self__, "table_name", table_name)

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


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

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

    @input_name.setter
    def input_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "input_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 DatasetLateDataRuleConfigurationArgs:
    def __init__(__self__, *,
                 delta_time_session_window_configuration: Optional[pulumi.Input['DatasetDeltaTimeSessionWindowConfigurationArgs']] = None):
        if delta_time_session_window_configuration is not None:
            pulumi.set(__self__, "delta_time_session_window_configuration", delta_time_session_window_configuration)

    @property
    @pulumi.getter(name="deltaTimeSessionWindowConfiguration")
    def delta_time_session_window_configuration(self) -> Optional[pulumi.Input['DatasetDeltaTimeSessionWindowConfigurationArgs']]:
        return pulumi.get(self, "delta_time_session_window_configuration")

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


@pulumi.input_type
class DatasetLateDataRuleArgs:
    def __init__(__self__, *,
                 rule_configuration: pulumi.Input['DatasetLateDataRuleConfigurationArgs'],
                 rule_name: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "rule_configuration", rule_configuration)
        if rule_name is not None:
            pulumi.set(__self__, "rule_name", rule_name)

    @property
    @pulumi.getter(name="ruleConfiguration")
    def rule_configuration(self) -> pulumi.Input['DatasetLateDataRuleConfigurationArgs']:
        return pulumi.get(self, "rule_configuration")

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

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

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


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

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

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


@pulumi.input_type
class DatasetQueryActionArgs:
    def __init__(__self__, *,
                 sql_query: pulumi.Input[str],
                 filters: Optional[pulumi.Input[Sequence[pulumi.Input['DatasetFilterArgs']]]] = None):
        pulumi.set(__self__, "sql_query", sql_query)
        if filters is not None:
            pulumi.set(__self__, "filters", filters)

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

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

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

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


@pulumi.input_type
class DatasetResourceConfigurationArgs:
    def __init__(__self__, *,
                 compute_type: pulumi.Input[str],
                 volume_size_in_gb: pulumi.Input[int]):
        pulumi.set(__self__, "compute_type", compute_type)
        pulumi.set(__self__, "volume_size_in_gb", volume_size_in_gb)

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

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

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

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


@pulumi.input_type
class DatasetRetentionPeriodArgs:
    def __init__(__self__, *,
                 number_of_days: pulumi.Input[int],
                 unlimited: pulumi.Input[bool]):
        pulumi.set(__self__, "number_of_days", number_of_days)
        pulumi.set(__self__, "unlimited", unlimited)

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

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

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

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


@pulumi.input_type
class DatasetS3DestinationConfigurationArgs:
    def __init__(__self__, *,
                 bucket: pulumi.Input[str],
                 key: pulumi.Input[str],
                 role_arn: pulumi.Input[str],
                 glue_configuration: Optional[pulumi.Input['DatasetGlueConfigurationArgs']] = None):
        pulumi.set(__self__, "bucket", bucket)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "role_arn", role_arn)
        if glue_configuration is not None:
            pulumi.set(__self__, "glue_configuration", glue_configuration)

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

    @bucket.setter
    def bucket(self, value: pulumi.Input[str]):
        pulumi.set(self, "bucket", 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(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="glueConfiguration")
    def glue_configuration(self) -> Optional[pulumi.Input['DatasetGlueConfigurationArgs']]:
        return pulumi.get(self, "glue_configuration")

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


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

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

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


@pulumi.input_type
class DatasetTagArgs:
    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 DatasetTriggeringDatasetArgs:
    def __init__(__self__, *,
                 dataset_name: pulumi.Input[str]):
        pulumi.set(__self__, "dataset_name", dataset_name)

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

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


@pulumi.input_type
class DatasetTriggerArgs:
    def __init__(__self__, *,
                 schedule: Optional[pulumi.Input['DatasetScheduleArgs']] = None,
                 triggering_dataset: Optional[pulumi.Input['DatasetTriggeringDatasetArgs']] = None):
        if schedule is not None:
            pulumi.set(__self__, "schedule", schedule)
        if triggering_dataset is not None:
            pulumi.set(__self__, "triggering_dataset", triggering_dataset)

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

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

    @property
    @pulumi.getter(name="triggeringDataset")
    def triggering_dataset(self) -> Optional[pulumi.Input['DatasetTriggeringDatasetArgs']]:
        return pulumi.get(self, "triggering_dataset")

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


@pulumi.input_type
class DatasetVariableArgs:
    def __init__(__self__, *,
                 variable_name: pulumi.Input[str],
                 dataset_content_version_value: Optional[pulumi.Input['DatasetDatasetContentVersionValueArgs']] = None,
                 double_value: Optional[pulumi.Input[float]] = None,
                 output_file_uri_value: Optional[pulumi.Input['DatasetOutputFileUriValueArgs']] = None,
                 string_value: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "variable_name", variable_name)
        if dataset_content_version_value is not None:
            pulumi.set(__self__, "dataset_content_version_value", dataset_content_version_value)
        if double_value is not None:
            pulumi.set(__self__, "double_value", double_value)
        if output_file_uri_value is not None:
            pulumi.set(__self__, "output_file_uri_value", output_file_uri_value)
        if string_value is not None:
            pulumi.set(__self__, "string_value", string_value)

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

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

    @property
    @pulumi.getter(name="datasetContentVersionValue")
    def dataset_content_version_value(self) -> Optional[pulumi.Input['DatasetDatasetContentVersionValueArgs']]:
        return pulumi.get(self, "dataset_content_version_value")

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

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

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

    @property
    @pulumi.getter(name="outputFileUriValue")
    def output_file_uri_value(self) -> Optional[pulumi.Input['DatasetOutputFileUriValueArgs']]:
        return pulumi.get(self, "output_file_uri_value")

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

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

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


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

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

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

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

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


@pulumi.input_type
class DatastoreColumnArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 type: pulumi.Input[str]):
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "type", type)

    @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
    def type(self) -> pulumi.Input[str]:
        return pulumi.get(self, "type")

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


@pulumi.input_type
class DatastoreCustomerManagedS3StorageArgs:
    def __init__(__self__, *,
                 bucket: pulumi.Input[str],
                 key_prefix: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "bucket", bucket)
        if key_prefix is not None:
            pulumi.set(__self__, "key_prefix", key_prefix)

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

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

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

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


@pulumi.input_type
class DatastoreCustomerManagedS3Args:
    def __init__(__self__, *,
                 bucket: pulumi.Input[str],
                 role_arn: pulumi.Input[str],
                 key_prefix: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "bucket", bucket)
        pulumi.set(__self__, "role_arn", role_arn)
        if key_prefix is not None:
            pulumi.set(__self__, "key_prefix", key_prefix)

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

    @bucket.setter
    def bucket(self, value: pulumi.Input[str]):
        pulumi.set(self, "bucket", 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="keyPrefix")
    def key_prefix(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "key_prefix")

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


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

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

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


@pulumi.input_type
class DatastoreDatastorePartitionArgs:
    def __init__(__self__, *,
                 partition: Optional[pulumi.Input['DatastorePartitionArgs']] = None,
                 timestamp_partition: Optional[pulumi.Input['DatastoreTimestampPartitionArgs']] = None):
        if partition is not None:
            pulumi.set(__self__, "partition", partition)
        if timestamp_partition is not None:
            pulumi.set(__self__, "timestamp_partition", timestamp_partition)

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

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

    @property
    @pulumi.getter(name="timestampPartition")
    def timestamp_partition(self) -> Optional[pulumi.Input['DatastoreTimestampPartitionArgs']]:
        return pulumi.get(self, "timestamp_partition")

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


@pulumi.input_type
class DatastoreDatastoreStorageArgs:
    def __init__(__self__, *,
                 customer_managed_s3: Optional[pulumi.Input['DatastoreCustomerManagedS3Args']] = None,
                 iot_site_wise_multi_layer_storage: Optional[pulumi.Input['DatastoreIotSiteWiseMultiLayerStorageArgs']] = None,
                 service_managed_s3: Optional[pulumi.Input['DatastoreServiceManagedS3Args']] = None):
        if customer_managed_s3 is not None:
            pulumi.set(__self__, "customer_managed_s3", customer_managed_s3)
        if iot_site_wise_multi_layer_storage is not None:
            pulumi.set(__self__, "iot_site_wise_multi_layer_storage", iot_site_wise_multi_layer_storage)
        if service_managed_s3 is not None:
            pulumi.set(__self__, "service_managed_s3", service_managed_s3)

    @property
    @pulumi.getter(name="customerManagedS3")
    def customer_managed_s3(self) -> Optional[pulumi.Input['DatastoreCustomerManagedS3Args']]:
        return pulumi.get(self, "customer_managed_s3")

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

    @property
    @pulumi.getter(name="iotSiteWiseMultiLayerStorage")
    def iot_site_wise_multi_layer_storage(self) -> Optional[pulumi.Input['DatastoreIotSiteWiseMultiLayerStorageArgs']]:
        return pulumi.get(self, "iot_site_wise_multi_layer_storage")

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

    @property
    @pulumi.getter(name="serviceManagedS3")
    def service_managed_s3(self) -> Optional[pulumi.Input['DatastoreServiceManagedS3Args']]:
        return pulumi.get(self, "service_managed_s3")

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


@pulumi.input_type
class DatastoreFileFormatConfigurationArgs:
    def __init__(__self__, *,
                 json_configuration: Optional[pulumi.Input['DatastoreJsonConfigurationArgs']] = None,
                 parquet_configuration: Optional[pulumi.Input['DatastoreParquetConfigurationArgs']] = None):
        if json_configuration is not None:
            pulumi.set(__self__, "json_configuration", json_configuration)
        if parquet_configuration is not None:
            pulumi.set(__self__, "parquet_configuration", parquet_configuration)

    @property
    @pulumi.getter(name="jsonConfiguration")
    def json_configuration(self) -> Optional[pulumi.Input['DatastoreJsonConfigurationArgs']]:
        return pulumi.get(self, "json_configuration")

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

    @property
    @pulumi.getter(name="parquetConfiguration")
    def parquet_configuration(self) -> Optional[pulumi.Input['DatastoreParquetConfigurationArgs']]:
        return pulumi.get(self, "parquet_configuration")

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


@pulumi.input_type
class DatastoreIotSiteWiseMultiLayerStorageArgs:
    def __init__(__self__, *,
                 customer_managed_s3_storage: pulumi.Input['DatastoreCustomerManagedS3StorageArgs']):
        pulumi.set(__self__, "customer_managed_s3_storage", customer_managed_s3_storage)

    @property
    @pulumi.getter(name="customerManagedS3Storage")
    def customer_managed_s3_storage(self) -> pulumi.Input['DatastoreCustomerManagedS3StorageArgs']:
        return pulumi.get(self, "customer_managed_s3_storage")

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


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


@pulumi.input_type
class DatastoreParquetConfigurationArgs:
    def __init__(__self__, *,
                 schema_definition: Optional[pulumi.Input['DatastoreSchemaDefinitionArgs']] = None):
        if schema_definition is not None:
            pulumi.set(__self__, "schema_definition", schema_definition)

    @property
    @pulumi.getter(name="schemaDefinition")
    def schema_definition(self) -> Optional[pulumi.Input['DatastoreSchemaDefinitionArgs']]:
        return pulumi.get(self, "schema_definition")

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


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

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

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


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

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

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

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

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


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

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

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


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


@pulumi.input_type
class DatastoreTagArgs:
    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 DatastoreTimestampPartitionArgs:
    def __init__(__self__, *,
                 attribute_name: pulumi.Input[str],
                 timestamp_format: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "attribute_name", attribute_name)
        if timestamp_format is not None:
            pulumi.set(__self__, "timestamp_format", timestamp_format)

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

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

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

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


@pulumi.input_type
class PipelineActivityArgs:
    def __init__(__self__, *,
                 add_attributes: Optional[pulumi.Input['PipelineAddAttributesArgs']] = None,
                 channel: Optional[pulumi.Input['PipelineChannelArgs']] = None,
                 datastore: Optional[pulumi.Input['PipelineDatastoreArgs']] = None,
                 device_registry_enrich: Optional[pulumi.Input['PipelineDeviceRegistryEnrichArgs']] = None,
                 device_shadow_enrich: Optional[pulumi.Input['PipelineDeviceShadowEnrichArgs']] = None,
                 filter: Optional[pulumi.Input['PipelineFilterArgs']] = None,
                 lambda_: Optional[pulumi.Input['PipelineLambdaArgs']] = None,
                 math: Optional[pulumi.Input['PipelineMathArgs']] = None,
                 remove_attributes: Optional[pulumi.Input['PipelineRemoveAttributesArgs']] = None,
                 select_attributes: Optional[pulumi.Input['PipelineSelectAttributesArgs']] = None):
        if add_attributes is not None:
            pulumi.set(__self__, "add_attributes", add_attributes)
        if channel is not None:
            pulumi.set(__self__, "channel", channel)
        if datastore is not None:
            pulumi.set(__self__, "datastore", datastore)
        if device_registry_enrich is not None:
            pulumi.set(__self__, "device_registry_enrich", device_registry_enrich)
        if device_shadow_enrich is not None:
            pulumi.set(__self__, "device_shadow_enrich", device_shadow_enrich)
        if filter is not None:
            pulumi.set(__self__, "filter", filter)
        if lambda_ is not None:
            pulumi.set(__self__, "lambda_", lambda_)
        if math is not None:
            pulumi.set(__self__, "math", math)
        if remove_attributes is not None:
            pulumi.set(__self__, "remove_attributes", remove_attributes)
        if select_attributes is not None:
            pulumi.set(__self__, "select_attributes", select_attributes)

    @property
    @pulumi.getter(name="addAttributes")
    def add_attributes(self) -> Optional[pulumi.Input['PipelineAddAttributesArgs']]:
        return pulumi.get(self, "add_attributes")

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

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

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

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

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

    @property
    @pulumi.getter(name="deviceRegistryEnrich")
    def device_registry_enrich(self) -> Optional[pulumi.Input['PipelineDeviceRegistryEnrichArgs']]:
        return pulumi.get(self, "device_registry_enrich")

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

    @property
    @pulumi.getter(name="deviceShadowEnrich")
    def device_shadow_enrich(self) -> Optional[pulumi.Input['PipelineDeviceShadowEnrichArgs']]:
        return pulumi.get(self, "device_shadow_enrich")

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

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

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

    @property
    @pulumi.getter(name="lambda")
    def lambda_(self) -> Optional[pulumi.Input['PipelineLambdaArgs']]:
        return pulumi.get(self, "lambda_")

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

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

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

    @property
    @pulumi.getter(name="removeAttributes")
    def remove_attributes(self) -> Optional[pulumi.Input['PipelineRemoveAttributesArgs']]:
        return pulumi.get(self, "remove_attributes")

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

    @property
    @pulumi.getter(name="selectAttributes")
    def select_attributes(self) -> Optional[pulumi.Input['PipelineSelectAttributesArgs']]:
        return pulumi.get(self, "select_attributes")

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


@pulumi.input_type
class PipelineAddAttributesArgs:
    def __init__(__self__, *,
                 attributes: Optional[Any] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 next: Optional[pulumi.Input[str]] = None):
        if attributes is not None:
            pulumi.set(__self__, "attributes", attributes)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if next is not None:
            pulumi.set(__self__, "next", next)

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

    @attributes.setter
    def attributes(self, value: Optional[Any]):
        pulumi.set(self, "attributes", 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)

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

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


@pulumi.input_type
class PipelineChannelArgs:
    def __init__(__self__, *,
                 channel_name: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 next: Optional[pulumi.Input[str]] = None):
        if channel_name is not None:
            pulumi.set(__self__, "channel_name", channel_name)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if next is not None:
            pulumi.set(__self__, "next", next)

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

    @channel_name.setter
    def channel_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "channel_name", 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)

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

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


@pulumi.input_type
class PipelineDatastoreArgs:
    def __init__(__self__, *,
                 datastore_name: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None):
        if datastore_name is not None:
            pulumi.set(__self__, "datastore_name", datastore_name)
        if name is not None:
            pulumi.set(__self__, "name", name)

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

    @datastore_name.setter
    def datastore_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "datastore_name", 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 PipelineDeviceRegistryEnrichArgs:
    def __init__(__self__, *,
                 attribute: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 next: Optional[pulumi.Input[str]] = None,
                 role_arn: Optional[pulumi.Input[str]] = None,
                 thing_name: Optional[pulumi.Input[str]] = None):
        if attribute is not None:
            pulumi.set(__self__, "attribute", attribute)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if next is not None:
            pulumi.set(__self__, "next", next)
        if role_arn is not None:
            pulumi.set(__self__, "role_arn", role_arn)
        if thing_name is not None:
            pulumi.set(__self__, "thing_name", thing_name)

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

    @attribute.setter
    def attribute(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "attribute", 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)

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

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

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

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

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

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


@pulumi.input_type
class PipelineDeviceShadowEnrichArgs:
    def __init__(__self__, *,
                 attribute: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 next: Optional[pulumi.Input[str]] = None,
                 role_arn: Optional[pulumi.Input[str]] = None,
                 thing_name: Optional[pulumi.Input[str]] = None):
        if attribute is not None:
            pulumi.set(__self__, "attribute", attribute)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if next is not None:
            pulumi.set(__self__, "next", next)
        if role_arn is not None:
            pulumi.set(__self__, "role_arn", role_arn)
        if thing_name is not None:
            pulumi.set(__self__, "thing_name", thing_name)

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

    @attribute.setter
    def attribute(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "attribute", 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)

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

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

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

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

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

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


@pulumi.input_type
class PipelineFilterArgs:
    def __init__(__self__, *,
                 filter: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 next: Optional[pulumi.Input[str]] = None):
        if filter is not None:
            pulumi.set(__self__, "filter", filter)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if next is not None:
            pulumi.set(__self__, "next", next)

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

    @filter.setter
    def filter(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "filter", 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)

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

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


@pulumi.input_type
class PipelineLambdaArgs:
    def __init__(__self__, *,
                 batch_size: Optional[pulumi.Input[int]] = None,
                 lambda_name: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 next: Optional[pulumi.Input[str]] = None):
        if batch_size is not None:
            pulumi.set(__self__, "batch_size", batch_size)
        if lambda_name is not None:
            pulumi.set(__self__, "lambda_name", lambda_name)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if next is not None:
            pulumi.set(__self__, "next", next)

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

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

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

    @lambda_name.setter
    def lambda_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "lambda_name", 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)

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

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


@pulumi.input_type
class PipelineMathArgs:
    def __init__(__self__, *,
                 attribute: Optional[pulumi.Input[str]] = None,
                 math: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 next: Optional[pulumi.Input[str]] = None):
        if attribute is not None:
            pulumi.set(__self__, "attribute", attribute)
        if math is not None:
            pulumi.set(__self__, "math", math)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if next is not None:
            pulumi.set(__self__, "next", next)

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

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

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

    @math.setter
    def math(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "math", 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)

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

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


@pulumi.input_type
class PipelineRemoveAttributesArgs:
    def __init__(__self__, *,
                 attributes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 next: Optional[pulumi.Input[str]] = None):
        if attributes is not None:
            pulumi.set(__self__, "attributes", attributes)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if next is not None:
            pulumi.set(__self__, "next", next)

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

    @attributes.setter
    def attributes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "attributes", 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)

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

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


@pulumi.input_type
class PipelineSelectAttributesArgs:
    def __init__(__self__, *,
                 attributes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 next: Optional[pulumi.Input[str]] = None):
        if attributes is not None:
            pulumi.set(__self__, "attributes", attributes)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if next is not None:
            pulumi.set(__self__, "next", next)

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

    @attributes.setter
    def attributes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "attributes", 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)

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

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


@pulumi.input_type
class PipelineTagArgs:
    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)


