# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import copy
import warnings
import sys
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
if sys.version_info >= (3, 11):
    from typing import NotRequired, TypedDict, TypeAlias
else:
    from typing_extensions import NotRequired, TypedDict, TypeAlias
from .. import _utilities
from . import outputs

__all__ = [
    'DiAlarmRuleNotificationSettings',
    'DiAlarmRuleNotificationSettingsNotificationChannel',
    'DiAlarmRuleNotificationSettingsNotificationReceiver',
    'DiAlarmRuleTriggerCondition',
    'DiJobDestinationDataSourceSetting',
    'DiJobJobSettings',
    'DiJobJobSettingsColumnDataTypeSetting',
    'DiJobJobSettingsCycleScheduleSettings',
    'DiJobJobSettingsDdlHandlingSetting',
    'DiJobJobSettingsRuntimeSetting',
    'DiJobResourceSettings',
    'DiJobResourceSettingsOfflineResourceSettings',
    'DiJobResourceSettingsRealtimeResourceSettings',
    'DiJobResourceSettingsScheduleResourceSettings',
    'DiJobSourceDataSourceSetting',
    'DiJobSourceDataSourceSettingDataSourceProperties',
    'DiJobTableMapping',
    'DiJobTableMappingSourceObjectSelectionRule',
    'DiJobTableMappingTransformationRule',
    'DiJobTransformationRule',
    'ProjectMemberRole',
    'GetFoldersFolderResult',
]

@pulumi.output_type
class DiAlarmRuleNotificationSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "inhibitionInterval":
            suggest = "inhibition_interval"
        elif key == "notificationChannels":
            suggest = "notification_channels"
        elif key == "notificationReceivers":
            suggest = "notification_receivers"

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

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

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

    def __init__(__self__, *,
                 inhibition_interval: Optional[int] = None,
                 notification_channels: Optional[Sequence['outputs.DiAlarmRuleNotificationSettingsNotificationChannel']] = None,
                 notification_receivers: Optional[Sequence['outputs.DiAlarmRuleNotificationSettingsNotificationReceiver']] = None):
        """
        :param int inhibition_interval: Alarm suppression interval, in minutes
        :param Sequence['DiAlarmRuleNotificationSettingsNotificationChannelArgs'] notification_channels: Alarm notification Channel See `notification_channels` below.
        :param Sequence['DiAlarmRuleNotificationSettingsNotificationReceiverArgs'] notification_receivers: List of alert notification recipients See `notification_receivers` below.
        """
        if inhibition_interval is not None:
            pulumi.set(__self__, "inhibition_interval", inhibition_interval)
        if notification_channels is not None:
            pulumi.set(__self__, "notification_channels", notification_channels)
        if notification_receivers is not None:
            pulumi.set(__self__, "notification_receivers", notification_receivers)

    @property
    @pulumi.getter(name="inhibitionInterval")
    def inhibition_interval(self) -> Optional[int]:
        """
        Alarm suppression interval, in minutes
        """
        return pulumi.get(self, "inhibition_interval")

    @property
    @pulumi.getter(name="notificationChannels")
    def notification_channels(self) -> Optional[Sequence['outputs.DiAlarmRuleNotificationSettingsNotificationChannel']]:
        """
        Alarm notification Channel See `notification_channels` below.
        """
        return pulumi.get(self, "notification_channels")

    @property
    @pulumi.getter(name="notificationReceivers")
    def notification_receivers(self) -> Optional[Sequence['outputs.DiAlarmRuleNotificationSettingsNotificationReceiver']]:
        """
        List of alert notification recipients See `notification_receivers` below.
        """
        return pulumi.get(self, "notification_receivers")


@pulumi.output_type
class DiAlarmRuleNotificationSettingsNotificationChannel(dict):
    def __init__(__self__, *,
                 channels: Optional[Sequence[str]] = None,
                 severity: Optional[str] = None):
        """
        :param Sequence[str] channels: Channel, optional enumeration value:
               
               Mail (Mail)
               
               Phone (Phone)
               
               Sms (Sms)
               
               Ding (DingTalk)
        """
        if channels is not None:
            pulumi.set(__self__, "channels", channels)
        if severity is not None:
            pulumi.set(__self__, "severity", severity)

    @property
    @pulumi.getter
    def channels(self) -> Optional[Sequence[str]]:
        """
        Channel, optional enumeration value:

        Mail (Mail)

        Phone (Phone)

        Sms (Sms)

        Ding (DingTalk)
        """
        return pulumi.get(self, "channels")

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


@pulumi.output_type
class DiAlarmRuleNotificationSettingsNotificationReceiver(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "receiverType":
            suggest = "receiver_type"
        elif key == "receiverValues":
            suggest = "receiver_values"

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

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

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

    def __init__(__self__, *,
                 receiver_type: Optional[str] = None,
                 receiver_values: Optional[Sequence[str]] = None):
        """
        :param str receiver_type: The type of the receiver. Valid values: AliyunUid/DingToken/FeishuToken/WebHookUrl.
        :param Sequence[str] receiver_values: Receiver Value List
        """
        if receiver_type is not None:
            pulumi.set(__self__, "receiver_type", receiver_type)
        if receiver_values is not None:
            pulumi.set(__self__, "receiver_values", receiver_values)

    @property
    @pulumi.getter(name="receiverType")
    def receiver_type(self) -> Optional[str]:
        """
        The type of the receiver. Valid values: AliyunUid/DingToken/FeishuToken/WebHookUrl.
        """
        return pulumi.get(self, "receiver_type")

    @property
    @pulumi.getter(name="receiverValues")
    def receiver_values(self) -> Optional[Sequence[str]]:
        """
        Receiver Value List
        """
        return pulumi.get(self, "receiver_values")


@pulumi.output_type
class DiAlarmRuleTriggerCondition(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ddlReportTags":
            suggest = "ddl_report_tags"

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

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

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

    def __init__(__self__, *,
                 ddl_report_tags: Optional[Sequence[str]] = None,
                 duration: Optional[int] = None,
                 severity: Optional[str] = None,
                 threshold: Optional[int] = None):
        """
        :param Sequence[str] ddl_report_tags: It takes effect only when the DDL notification is issued. The list of effective DDLs is required.
        :param int duration: Alarm calculation time interval, unit minute
        :param str severity: Severity, optional enumeration value:
               
               Warning
               
               Critical
        :param int threshold: Alarm threshold.
               
               Task status alarm: no need to fill in the threshold.
               
               failover alarm: The threshold is the number of failover alarms.
               
               Task Delay Alarm: The threshold is the delay duration, in seconds.
        """
        if ddl_report_tags is not None:
            pulumi.set(__self__, "ddl_report_tags", ddl_report_tags)
        if duration is not None:
            pulumi.set(__self__, "duration", duration)
        if severity is not None:
            pulumi.set(__self__, "severity", severity)
        if threshold is not None:
            pulumi.set(__self__, "threshold", threshold)

    @property
    @pulumi.getter(name="ddlReportTags")
    def ddl_report_tags(self) -> Optional[Sequence[str]]:
        """
        It takes effect only when the DDL notification is issued. The list of effective DDLs is required.
        """
        return pulumi.get(self, "ddl_report_tags")

    @property
    @pulumi.getter
    def duration(self) -> Optional[int]:
        """
        Alarm calculation time interval, unit minute
        """
        return pulumi.get(self, "duration")

    @property
    @pulumi.getter
    def severity(self) -> Optional[str]:
        """
        Severity, optional enumeration value:

        Warning

        Critical
        """
        return pulumi.get(self, "severity")

    @property
    @pulumi.getter
    def threshold(self) -> Optional[int]:
        """
        Alarm threshold.

        Task status alarm: no need to fill in the threshold.

        failover alarm: The threshold is the number of failover alarms.

        Task Delay Alarm: The threshold is the delay duration, in seconds.
        """
        return pulumi.get(self, "threshold")


@pulumi.output_type
class DiJobDestinationDataSourceSetting(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "dataSourceName":
            suggest = "data_source_name"

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

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

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

    def __init__(__self__, *,
                 data_source_name: Optional[str] = None):
        """
        :param str data_source_name: Destination data source name
        """
        if data_source_name is not None:
            pulumi.set(__self__, "data_source_name", data_source_name)

    @property
    @pulumi.getter(name="dataSourceName")
    def data_source_name(self) -> Optional[str]:
        """
        Destination data source name
        """
        return pulumi.get(self, "data_source_name")


@pulumi.output_type
class DiJobJobSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "channelSettings":
            suggest = "channel_settings"
        elif key == "columnDataTypeSettings":
            suggest = "column_data_type_settings"
        elif key == "cycleScheduleSettings":
            suggest = "cycle_schedule_settings"
        elif key == "ddlHandlingSettings":
            suggest = "ddl_handling_settings"
        elif key == "runtimeSettings":
            suggest = "runtime_settings"

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

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

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

    def __init__(__self__, *,
                 channel_settings: Optional[str] = None,
                 column_data_type_settings: Optional[Sequence['outputs.DiJobJobSettingsColumnDataTypeSetting']] = None,
                 cycle_schedule_settings: Optional['outputs.DiJobJobSettingsCycleScheduleSettings'] = None,
                 ddl_handling_settings: Optional[Sequence['outputs.DiJobJobSettingsDdlHandlingSetting']] = None,
                 runtime_settings: Optional[Sequence['outputs.DiJobJobSettingsRuntimeSetting']] = None):
        """
        :param str channel_settings: Channel-related task settings, in the form of a Json String.
               
               For example,
               {"structInfo":"MANAGED","storageType":"TEXTFILE","writeMode":"APPEND","partitionColumns":[{"columnName":"pt","columnType":"STRING","comment":""}],"fieldDelimiter":""}
        :param Sequence['DiJobJobSettingsColumnDataTypeSettingArgs'] column_data_type_settings: Column type mapping of the synchronization task See `column_data_type_settings` below.
        :param 'DiJobJobSettingsCycleScheduleSettingsArgs' cycle_schedule_settings: Periodic scheduling settings See `cycle_schedule_settings` below.
        :param Sequence['DiJobJobSettingsDdlHandlingSettingArgs'] ddl_handling_settings: List of DDL processing settings for synchronization tasks See `ddl_handling_settings` below.
        :param Sequence['DiJobJobSettingsRuntimeSettingArgs'] runtime_settings: Run-time setting parameter list See `runtime_settings` below.
        """
        if channel_settings is not None:
            pulumi.set(__self__, "channel_settings", channel_settings)
        if column_data_type_settings is not None:
            pulumi.set(__self__, "column_data_type_settings", column_data_type_settings)
        if cycle_schedule_settings is not None:
            pulumi.set(__self__, "cycle_schedule_settings", cycle_schedule_settings)
        if ddl_handling_settings is not None:
            pulumi.set(__self__, "ddl_handling_settings", ddl_handling_settings)
        if runtime_settings is not None:
            pulumi.set(__self__, "runtime_settings", runtime_settings)

    @property
    @pulumi.getter(name="channelSettings")
    def channel_settings(self) -> Optional[str]:
        """
        Channel-related task settings, in the form of a Json String.

        For example,
        {"structInfo":"MANAGED","storageType":"TEXTFILE","writeMode":"APPEND","partitionColumns":[{"columnName":"pt","columnType":"STRING","comment":""}],"fieldDelimiter":""}
        """
        return pulumi.get(self, "channel_settings")

    @property
    @pulumi.getter(name="columnDataTypeSettings")
    def column_data_type_settings(self) -> Optional[Sequence['outputs.DiJobJobSettingsColumnDataTypeSetting']]:
        """
        Column type mapping of the synchronization task See `column_data_type_settings` below.
        """
        return pulumi.get(self, "column_data_type_settings")

    @property
    @pulumi.getter(name="cycleScheduleSettings")
    def cycle_schedule_settings(self) -> Optional['outputs.DiJobJobSettingsCycleScheduleSettings']:
        """
        Periodic scheduling settings See `cycle_schedule_settings` below.
        """
        return pulumi.get(self, "cycle_schedule_settings")

    @property
    @pulumi.getter(name="ddlHandlingSettings")
    def ddl_handling_settings(self) -> Optional[Sequence['outputs.DiJobJobSettingsDdlHandlingSetting']]:
        """
        List of DDL processing settings for synchronization tasks See `ddl_handling_settings` below.
        """
        return pulumi.get(self, "ddl_handling_settings")

    @property
    @pulumi.getter(name="runtimeSettings")
    def runtime_settings(self) -> Optional[Sequence['outputs.DiJobJobSettingsRuntimeSetting']]:
        """
        Run-time setting parameter list See `runtime_settings` below.
        """
        return pulumi.get(self, "runtime_settings")


@pulumi.output_type
class DiJobJobSettingsColumnDataTypeSetting(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "destinationDataType":
            suggest = "destination_data_type"
        elif key == "sourceDataType":
            suggest = "source_data_type"

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

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

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

    def __init__(__self__, *,
                 destination_data_type: Optional[str] = None,
                 source_data_type: Optional[str] = None):
        """
        :param str destination_data_type: The destination type of the mapping relationship
        :param str source_data_type: The source type of the mapping type
        """
        if destination_data_type is not None:
            pulumi.set(__self__, "destination_data_type", destination_data_type)
        if source_data_type is not None:
            pulumi.set(__self__, "source_data_type", source_data_type)

    @property
    @pulumi.getter(name="destinationDataType")
    def destination_data_type(self) -> Optional[str]:
        """
        The destination type of the mapping relationship
        """
        return pulumi.get(self, "destination_data_type")

    @property
    @pulumi.getter(name="sourceDataType")
    def source_data_type(self) -> Optional[str]:
        """
        The source type of the mapping type
        """
        return pulumi.get(self, "source_data_type")


@pulumi.output_type
class DiJobJobSettingsCycleScheduleSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cycleMigrationType":
            suggest = "cycle_migration_type"
        elif key == "scheduleParameters":
            suggest = "schedule_parameters"

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

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

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

    def __init__(__self__, *,
                 cycle_migration_type: Optional[str] = None,
                 schedule_parameters: Optional[str] = None):
        """
        :param str cycle_migration_type: The type of synchronization that requires periodic scheduling. Value range:
               
               Full: Full
               
               OfflineIncremental: offline increment
        :param str schedule_parameters: Scheduling Parameters
        """
        if cycle_migration_type is not None:
            pulumi.set(__self__, "cycle_migration_type", cycle_migration_type)
        if schedule_parameters is not None:
            pulumi.set(__self__, "schedule_parameters", schedule_parameters)

    @property
    @pulumi.getter(name="cycleMigrationType")
    def cycle_migration_type(self) -> Optional[str]:
        """
        The type of synchronization that requires periodic scheduling. Value range:

        Full: Full

        OfflineIncremental: offline increment
        """
        return pulumi.get(self, "cycle_migration_type")

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


@pulumi.output_type
class DiJobJobSettingsDdlHandlingSetting(dict):
    def __init__(__self__, *,
                 action: Optional[str] = None,
                 type: Optional[str] = None):
        """
        :param str type: DDL type, optional enumeration value:
               
               RenameColumn (rename column)
               
               ModifyColumn (rename column)
               
               CreateTable (Rename Column)
               
               TruncateTable (empty table)
               
               DropTable (delete table)
        """
        if action is not None:
            pulumi.set(__self__, "action", action)
        if type is not None:
            pulumi.set(__self__, "type", type)

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

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        DDL type, optional enumeration value:

        RenameColumn (rename column)

        ModifyColumn (rename column)

        CreateTable (Rename Column)

        TruncateTable (empty table)

        DropTable (delete table)
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class DiJobJobSettingsRuntimeSetting(dict):
    def __init__(__self__, *,
                 name: Optional[str] = None,
                 value: Optional[str] = None):
        """
        :param str name: Set name, optional ENUM value:
               
               runtime.offline.speed.limit.mb (valid when runtime.offline.speed.limit.enable = true)
               
               runtime.offline.speed.limit.enable
               
               dst.offline.connection.max (the maximum number of write connections for offline batch tasks)
               
               runtime.offline.concurrent (offline batch synchronization task concurrency)
               
               dst.realtime.connection.max (maximum number of write connections for real-time tasks)
               
               runtime.enable.auto.create.schema (whether to automatically create a schema on the target side)
               
               src.offline.datasource.max.connection (maximum number of source connections for offline batch tasks)
               
               runtime.realtime.concurrent (real-time task concurrency)
        :param str value: Runtime setting value
        """
        if name is not None:
            pulumi.set(__self__, "name", name)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def name(self) -> Optional[str]:
        """
        Set name, optional ENUM value:

        runtime.offline.speed.limit.mb (valid when runtime.offline.speed.limit.enable = true)

        runtime.offline.speed.limit.enable

        dst.offline.connection.max (the maximum number of write connections for offline batch tasks)

        runtime.offline.concurrent (offline batch synchronization task concurrency)

        dst.realtime.connection.max (maximum number of write connections for real-time tasks)

        runtime.enable.auto.create.schema (whether to automatically create a schema on the target side)

        src.offline.datasource.max.connection (maximum number of source connections for offline batch tasks)

        runtime.realtime.concurrent (real-time task concurrency)
        """
        return pulumi.get(self, "name")

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


@pulumi.output_type
class DiJobResourceSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "offlineResourceSettings":
            suggest = "offline_resource_settings"
        elif key == "realtimeResourceSettings":
            suggest = "realtime_resource_settings"
        elif key == "scheduleResourceSettings":
            suggest = "schedule_resource_settings"

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

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

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

    def __init__(__self__, *,
                 offline_resource_settings: Optional['outputs.DiJobResourceSettingsOfflineResourceSettings'] = None,
                 realtime_resource_settings: Optional['outputs.DiJobResourceSettingsRealtimeResourceSettings'] = None,
                 schedule_resource_settings: Optional['outputs.DiJobResourceSettingsScheduleResourceSettings'] = None):
        """
        :param 'DiJobResourceSettingsOfflineResourceSettingsArgs' offline_resource_settings: Offline Resource Group configuration See `offline_resource_settings` below.
        :param 'DiJobResourceSettingsRealtimeResourceSettingsArgs' realtime_resource_settings: Real-time Resource Group See `realtime_resource_settings` below.
        :param 'DiJobResourceSettingsScheduleResourceSettingsArgs' schedule_resource_settings: Scheduling Resource Groups See `schedule_resource_settings` below.
        """
        if offline_resource_settings is not None:
            pulumi.set(__self__, "offline_resource_settings", offline_resource_settings)
        if realtime_resource_settings is not None:
            pulumi.set(__self__, "realtime_resource_settings", realtime_resource_settings)
        if schedule_resource_settings is not None:
            pulumi.set(__self__, "schedule_resource_settings", schedule_resource_settings)

    @property
    @pulumi.getter(name="offlineResourceSettings")
    def offline_resource_settings(self) -> Optional['outputs.DiJobResourceSettingsOfflineResourceSettings']:
        """
        Offline Resource Group configuration See `offline_resource_settings` below.
        """
        return pulumi.get(self, "offline_resource_settings")

    @property
    @pulumi.getter(name="realtimeResourceSettings")
    def realtime_resource_settings(self) -> Optional['outputs.DiJobResourceSettingsRealtimeResourceSettings']:
        """
        Real-time Resource Group See `realtime_resource_settings` below.
        """
        return pulumi.get(self, "realtime_resource_settings")

    @property
    @pulumi.getter(name="scheduleResourceSettings")
    def schedule_resource_settings(self) -> Optional['outputs.DiJobResourceSettingsScheduleResourceSettings']:
        """
        Scheduling Resource Groups See `schedule_resource_settings` below.
        """
        return pulumi.get(self, "schedule_resource_settings")


@pulumi.output_type
class DiJobResourceSettingsOfflineResourceSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "requestedCu":
            suggest = "requested_cu"
        elif key == "resourceGroupIdentifier":
            suggest = "resource_group_identifier"

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

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

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

    def __init__(__self__, *,
                 requested_cu: Optional[float] = None,
                 resource_group_identifier: Optional[str] = None):
        """
        :param float requested_cu: Scheduling resource group cu
        :param str resource_group_identifier: Scheduling resource group name
        """
        if requested_cu is not None:
            pulumi.set(__self__, "requested_cu", requested_cu)
        if resource_group_identifier is not None:
            pulumi.set(__self__, "resource_group_identifier", resource_group_identifier)

    @property
    @pulumi.getter(name="requestedCu")
    def requested_cu(self) -> Optional[float]:
        """
        Scheduling resource group cu
        """
        return pulumi.get(self, "requested_cu")

    @property
    @pulumi.getter(name="resourceGroupIdentifier")
    def resource_group_identifier(self) -> Optional[str]:
        """
        Scheduling resource group name
        """
        return pulumi.get(self, "resource_group_identifier")


@pulumi.output_type
class DiJobResourceSettingsRealtimeResourceSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "requestedCu":
            suggest = "requested_cu"
        elif key == "resourceGroupIdentifier":
            suggest = "resource_group_identifier"

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

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

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

    def __init__(__self__, *,
                 requested_cu: Optional[float] = None,
                 resource_group_identifier: Optional[str] = None):
        """
        :param float requested_cu: Scheduling resource group cu
        :param str resource_group_identifier: Scheduling resource group name
        """
        if requested_cu is not None:
            pulumi.set(__self__, "requested_cu", requested_cu)
        if resource_group_identifier is not None:
            pulumi.set(__self__, "resource_group_identifier", resource_group_identifier)

    @property
    @pulumi.getter(name="requestedCu")
    def requested_cu(self) -> Optional[float]:
        """
        Scheduling resource group cu
        """
        return pulumi.get(self, "requested_cu")

    @property
    @pulumi.getter(name="resourceGroupIdentifier")
    def resource_group_identifier(self) -> Optional[str]:
        """
        Scheduling resource group name
        """
        return pulumi.get(self, "resource_group_identifier")


@pulumi.output_type
class DiJobResourceSettingsScheduleResourceSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "requestedCu":
            suggest = "requested_cu"
        elif key == "resourceGroupIdentifier":
            suggest = "resource_group_identifier"

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

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

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

    def __init__(__self__, *,
                 requested_cu: Optional[float] = None,
                 resource_group_identifier: Optional[str] = None):
        """
        :param float requested_cu: Scheduling resource group cu
        :param str resource_group_identifier: Scheduling resource group name
        """
        if requested_cu is not None:
            pulumi.set(__self__, "requested_cu", requested_cu)
        if resource_group_identifier is not None:
            pulumi.set(__self__, "resource_group_identifier", resource_group_identifier)

    @property
    @pulumi.getter(name="requestedCu")
    def requested_cu(self) -> Optional[float]:
        """
        Scheduling resource group cu
        """
        return pulumi.get(self, "requested_cu")

    @property
    @pulumi.getter(name="resourceGroupIdentifier")
    def resource_group_identifier(self) -> Optional[str]:
        """
        Scheduling resource group name
        """
        return pulumi.get(self, "resource_group_identifier")


@pulumi.output_type
class DiJobSourceDataSourceSetting(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "dataSourceName":
            suggest = "data_source_name"
        elif key == "dataSourceProperties":
            suggest = "data_source_properties"

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

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

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

    def __init__(__self__, *,
                 data_source_name: Optional[str] = None,
                 data_source_properties: Optional['outputs.DiJobSourceDataSourceSettingDataSourceProperties'] = None):
        """
        :param str data_source_name: Data source name of a single source
        :param 'DiJobSourceDataSourceSettingDataSourcePropertiesArgs' data_source_properties: Single Source Data Source Properties See `data_source_properties` below.
        """
        if data_source_name is not None:
            pulumi.set(__self__, "data_source_name", data_source_name)
        if data_source_properties is not None:
            pulumi.set(__self__, "data_source_properties", data_source_properties)

    @property
    @pulumi.getter(name="dataSourceName")
    def data_source_name(self) -> Optional[str]:
        """
        Data source name of a single source
        """
        return pulumi.get(self, "data_source_name")

    @property
    @pulumi.getter(name="dataSourceProperties")
    def data_source_properties(self) -> Optional['outputs.DiJobSourceDataSourceSettingDataSourceProperties']:
        """
        Single Source Data Source Properties See `data_source_properties` below.
        """
        return pulumi.get(self, "data_source_properties")


@pulumi.output_type
class DiJobSourceDataSourceSettingDataSourceProperties(dict):
    def __init__(__self__, *,
                 encoding: Optional[str] = None,
                 timezone: Optional[str] = None):
        """
        :param str encoding: Data Source Encoding
        :param str timezone: Data Source Time Zone
        """
        if encoding is not None:
            pulumi.set(__self__, "encoding", encoding)
        if timezone is not None:
            pulumi.set(__self__, "timezone", timezone)

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

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


@pulumi.output_type
class DiJobTableMapping(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "sourceObjectSelectionRules":
            suggest = "source_object_selection_rules"
        elif key == "transformationRules":
            suggest = "transformation_rules"

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

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

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

    def __init__(__self__, *,
                 source_object_selection_rules: Optional[Sequence['outputs.DiJobTableMappingSourceObjectSelectionRule']] = None,
                 transformation_rules: Optional[Sequence['outputs.DiJobTableMappingTransformationRule']] = None):
        """
        :param Sequence['DiJobTableMappingSourceObjectSelectionRuleArgs'] source_object_selection_rules: Each rule can select different types of source objects to be synchronized, such as source database and source data table. See `source_object_selection_rules` below.
        :param Sequence['DiJobTableMappingTransformationRuleArgs'] transformation_rules: A list of conversion rule definitions for a synchronization object. Each element in the list defines a conversion rule. See `transformation_rules` below.
        """
        if source_object_selection_rules is not None:
            pulumi.set(__self__, "source_object_selection_rules", source_object_selection_rules)
        if transformation_rules is not None:
            pulumi.set(__self__, "transformation_rules", transformation_rules)

    @property
    @pulumi.getter(name="sourceObjectSelectionRules")
    def source_object_selection_rules(self) -> Optional[Sequence['outputs.DiJobTableMappingSourceObjectSelectionRule']]:
        """
        Each rule can select different types of source objects to be synchronized, such as source database and source data table. See `source_object_selection_rules` below.
        """
        return pulumi.get(self, "source_object_selection_rules")

    @property
    @pulumi.getter(name="transformationRules")
    def transformation_rules(self) -> Optional[Sequence['outputs.DiJobTableMappingTransformationRule']]:
        """
        A list of conversion rule definitions for a synchronization object. Each element in the list defines a conversion rule. See `transformation_rules` below.
        """
        return pulumi.get(self, "transformation_rules")


@pulumi.output_type
class DiJobTableMappingSourceObjectSelectionRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "expressionType":
            suggest = "expression_type"
        elif key == "objectType":
            suggest = "object_type"

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

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

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

    def __init__(__self__, *,
                 action: Optional[str] = None,
                 expression: Optional[str] = None,
                 expression_type: Optional[str] = None,
                 object_type: Optional[str] = None):
        """
        :param str expression: Expression, such as mysql_table_1
        :param str expression_type: Expression type, value range: Exact/Regex
        :param str object_type: Object type, optional enumeration value:
               
               Table (Table)
               
               Database
        """
        if action is not None:
            pulumi.set(__self__, "action", action)
        if expression is not None:
            pulumi.set(__self__, "expression", expression)
        if expression_type is not None:
            pulumi.set(__self__, "expression_type", expression_type)
        if object_type is not None:
            pulumi.set(__self__, "object_type", object_type)

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

    @property
    @pulumi.getter
    def expression(self) -> Optional[str]:
        """
        Expression, such as mysql_table_1
        """
        return pulumi.get(self, "expression")

    @property
    @pulumi.getter(name="expressionType")
    def expression_type(self) -> Optional[str]:
        """
        Expression type, value range: Exact/Regex
        """
        return pulumi.get(self, "expression_type")

    @property
    @pulumi.getter(name="objectType")
    def object_type(self) -> Optional[str]:
        """
        Object type, optional enumeration value:

        Table (Table)

        Database
        """
        return pulumi.get(self, "object_type")


@pulumi.output_type
class DiJobTableMappingTransformationRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ruleActionType":
            suggest = "rule_action_type"
        elif key == "ruleName":
            suggest = "rule_name"
        elif key == "ruleTargetType":
            suggest = "rule_target_type"

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

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

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

    def __init__(__self__, *,
                 rule_action_type: Optional[str] = None,
                 rule_name: Optional[str] = None,
                 rule_target_type: Optional[str] = None):
        """
        :param str rule_action_type: Action type, optional enumeration value:
               
               DefinePrimaryKey (defines the primary key)
               
               Rename
               
               AddColumn (increase column)
               
               HandleDml(DML handling)
               
               DefineIncrementalCondition
        :param str rule_name: Rule Name
        :param str rule_target_type: Target type of action, optional enumeration value:
               
               Table (Table)
               
               Schema(schema)
        """
        if rule_action_type is not None:
            pulumi.set(__self__, "rule_action_type", rule_action_type)
        if rule_name is not None:
            pulumi.set(__self__, "rule_name", rule_name)
        if rule_target_type is not None:
            pulumi.set(__self__, "rule_target_type", rule_target_type)

    @property
    @pulumi.getter(name="ruleActionType")
    def rule_action_type(self) -> Optional[str]:
        """
        Action type, optional enumeration value:

        DefinePrimaryKey (defines the primary key)

        Rename

        AddColumn (increase column)

        HandleDml(DML handling)

        DefineIncrementalCondition
        """
        return pulumi.get(self, "rule_action_type")

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

    @property
    @pulumi.getter(name="ruleTargetType")
    def rule_target_type(self) -> Optional[str]:
        """
        Target type of action, optional enumeration value:

        Table (Table)

        Schema(schema)
        """
        return pulumi.get(self, "rule_target_type")


@pulumi.output_type
class DiJobTransformationRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ruleActionType":
            suggest = "rule_action_type"
        elif key == "ruleExpression":
            suggest = "rule_expression"
        elif key == "ruleName":
            suggest = "rule_name"
        elif key == "ruleTargetType":
            suggest = "rule_target_type"

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

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

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

    def __init__(__self__, *,
                 rule_action_type: Optional[str] = None,
                 rule_expression: Optional[str] = None,
                 rule_name: Optional[str] = None,
                 rule_target_type: Optional[str] = None):
        """
        :param str rule_action_type: Action type, optional enumeration value:
               
               DefinePrimaryKey (defines the primary key)
               
               Rename
               
               AddColumn (increase column)
               
               HandleDml(DML handling)
               
               DefineIncrementalCondition
        :param str rule_expression: Regular expression, in json string format.
               
               Example renaming rule (Rename): {"expression":"${srcDatasourceName}_${srcDatabaseName}_0922","variables":[{"variableName":"srcDatabaseName","variableRules":[{"from":"fromdb","to":"todb"}]}]}
        :param str rule_name: Rule Name
        :param str rule_target_type: Target type of action, optional enumeration value:
               
               Table (Table)
               
               Schema(schema)
        """
        if rule_action_type is not None:
            pulumi.set(__self__, "rule_action_type", rule_action_type)
        if rule_expression is not None:
            pulumi.set(__self__, "rule_expression", rule_expression)
        if rule_name is not None:
            pulumi.set(__self__, "rule_name", rule_name)
        if rule_target_type is not None:
            pulumi.set(__self__, "rule_target_type", rule_target_type)

    @property
    @pulumi.getter(name="ruleActionType")
    def rule_action_type(self) -> Optional[str]:
        """
        Action type, optional enumeration value:

        DefinePrimaryKey (defines the primary key)

        Rename

        AddColumn (increase column)

        HandleDml(DML handling)

        DefineIncrementalCondition
        """
        return pulumi.get(self, "rule_action_type")

    @property
    @pulumi.getter(name="ruleExpression")
    def rule_expression(self) -> Optional[str]:
        """
        Regular expression, in json string format.

        Example renaming rule (Rename): {"expression":"${srcDatasourceName}_${srcDatabaseName}_0922","variables":[{"variableName":"srcDatabaseName","variableRules":[{"from":"fromdb","to":"todb"}]}]}
        """
        return pulumi.get(self, "rule_expression")

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

    @property
    @pulumi.getter(name="ruleTargetType")
    def rule_target_type(self) -> Optional[str]:
        """
        Target type of action, optional enumeration value:

        Table (Table)

        Schema(schema)
        """
        return pulumi.get(self, "rule_target_type")


@pulumi.output_type
class ProjectMemberRole(dict):
    def __init__(__self__, *,
                 code: Optional[str] = None,
                 name: Optional[str] = None,
                 type: Optional[str] = None):
        """
        :param str code: Project Role Code.
        :param str name: project role name
        :param str type: project role type
        """
        if code is not None:
            pulumi.set(__self__, "code", code)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if type is not None:
            pulumi.set(__self__, "type", type)

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

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

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


@pulumi.output_type
class GetFoldersFolderResult(dict):
    def __init__(__self__, *,
                 folder_id: str,
                 folder_path: str,
                 id: str,
                 project_id: str):
        """
        :param str folder_path: Folder Path.
        :param str id: The Folder ID.
        :param str project_id: The ID of the project.
        """
        pulumi.set(__self__, "folder_id", folder_id)
        pulumi.set(__self__, "folder_path", folder_path)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "project_id", project_id)

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

    @property
    @pulumi.getter(name="folderPath")
    def folder_path(self) -> str:
        """
        Folder Path.
        """
        return pulumi.get(self, "folder_path")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The Folder ID.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> str:
        """
        The ID of the project.
        """
        return pulumi.get(self, "project_id")


