# coding=utf-8
# *** WARNING: this file was generated by the Pulumi SDK Generator. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
from ._enums import *

__all__ = [
    'ConnectorProfileAmplitudeConnectorProfileCredentials',
    'ConnectorProfileConnectorOAuthRequest',
    'ConnectorProfileConnectorProfileConfig',
    'ConnectorProfileConnectorProfileCredentials',
    'ConnectorProfileConnectorProfileProperties',
    'ConnectorProfileDatadogConnectorProfileCredentials',
    'ConnectorProfileDatadogConnectorProfileProperties',
    'ConnectorProfileDynatraceConnectorProfileCredentials',
    'ConnectorProfileDynatraceConnectorProfileProperties',
    'ConnectorProfileGoogleAnalyticsConnectorProfileCredentials',
    'ConnectorProfileInforNexusConnectorProfileCredentials',
    'ConnectorProfileInforNexusConnectorProfileProperties',
    'ConnectorProfileMarketoConnectorProfileCredentials',
    'ConnectorProfileMarketoConnectorProfileProperties',
    'ConnectorProfileRedshiftConnectorProfileCredentials',
    'ConnectorProfileRedshiftConnectorProfileProperties',
    'ConnectorProfileSalesforceConnectorProfileCredentials',
    'ConnectorProfileSalesforceConnectorProfileProperties',
    'ConnectorProfileServiceNowConnectorProfileCredentials',
    'ConnectorProfileServiceNowConnectorProfileProperties',
    'ConnectorProfileSingularConnectorProfileCredentials',
    'ConnectorProfileSlackConnectorProfileCredentials',
    'ConnectorProfileSlackConnectorProfileProperties',
    'ConnectorProfileSnowflakeConnectorProfileCredentials',
    'ConnectorProfileSnowflakeConnectorProfileProperties',
    'ConnectorProfileTrendmicroConnectorProfileCredentials',
    'ConnectorProfileVeevaConnectorProfileCredentials',
    'ConnectorProfileVeevaConnectorProfileProperties',
    'ConnectorProfileZendeskConnectorProfileCredentials',
    'ConnectorProfileZendeskConnectorProfileProperties',
    'FlowAggregationConfig',
    'FlowAmplitudeSourceProperties',
    'FlowConnectorOperator',
    'FlowDatadogSourceProperties',
    'FlowDestinationConnectorProperties',
    'FlowDestinationFlowConfig',
    'FlowDynatraceSourceProperties',
    'FlowErrorHandlingConfig',
    'FlowEventBridgeDestinationProperties',
    'FlowGoogleAnalyticsSourceProperties',
    'FlowIncrementalPullConfig',
    'FlowInforNexusSourceProperties',
    'FlowLookoutMetricsDestinationProperties',
    'FlowMarketoSourceProperties',
    'FlowPrefixConfig',
    'FlowRedshiftDestinationProperties',
    'FlowS3DestinationProperties',
    'FlowS3OutputFormatConfig',
    'FlowS3SourceProperties',
    'FlowSalesforceDestinationProperties',
    'FlowSalesforceSourceProperties',
    'FlowScheduledTriggerProperties',
    'FlowServiceNowSourceProperties',
    'FlowSingularSourceProperties',
    'FlowSlackSourceProperties',
    'FlowSnowflakeDestinationProperties',
    'FlowSourceConnectorProperties',
    'FlowSourceFlowConfig',
    'FlowTag',
    'FlowTask',
    'FlowTaskPropertiesObject',
    'FlowTrendmicroSourceProperties',
    'FlowTriggerConfig',
    'FlowUpsolverDestinationProperties',
    'FlowUpsolverS3OutputFormatConfig',
    'FlowVeevaSourceProperties',
    'FlowZendeskDestinationProperties',
    'FlowZendeskSourceProperties',
]

@pulumi.output_type
class ConnectorProfileAmplitudeConnectorProfileCredentials(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "apiKey":
            suggest = "api_key"
        elif key == "secretKey":
            suggest = "secret_key"

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

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

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

    def __init__(__self__, *,
                 api_key: str,
                 secret_key: str):
        """
        :param str api_key: A unique alphanumeric identiﬁer used to authenticate a user, developer, or calling program to your API.
        """
        pulumi.set(__self__, "api_key", api_key)
        pulumi.set(__self__, "secret_key", secret_key)

    @property
    @pulumi.getter(name="apiKey")
    def api_key(self) -> str:
        """
        A unique alphanumeric identiﬁer used to authenticate a user, developer, or calling program to your API.
        """
        return pulumi.get(self, "api_key")

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


@pulumi.output_type
class ConnectorProfileConnectorOAuthRequest(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "authCode":
            suggest = "auth_code"
        elif key == "redirectUri":
            suggest = "redirect_uri"

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

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

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

    def __init__(__self__, *,
                 auth_code: Optional[str] = None,
                 redirect_uri: Optional[str] = None):
        """
        :param str auth_code: The code provided by the connector when it has been authenticated via the connected app.
        :param str redirect_uri: The URL to which the authentication server redirects the browser after authorization has been
               granted.
        """
        if auth_code is not None:
            pulumi.set(__self__, "auth_code", auth_code)
        if redirect_uri is not None:
            pulumi.set(__self__, "redirect_uri", redirect_uri)

    @property
    @pulumi.getter(name="authCode")
    def auth_code(self) -> Optional[str]:
        """
        The code provided by the connector when it has been authenticated via the connected app.
        """
        return pulumi.get(self, "auth_code")

    @property
    @pulumi.getter(name="redirectUri")
    def redirect_uri(self) -> Optional[str]:
        """
        The URL to which the authentication server redirects the browser after authorization has been
        granted.
        """
        return pulumi.get(self, "redirect_uri")


@pulumi.output_type
class ConnectorProfileConnectorProfileConfig(dict):
    """
    Connector specific configurations needed to create connector profile
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "connectorProfileCredentials":
            suggest = "connector_profile_credentials"
        elif key == "connectorProfileProperties":
            suggest = "connector_profile_properties"

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

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

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

    def __init__(__self__, *,
                 connector_profile_credentials: 'outputs.ConnectorProfileConnectorProfileCredentials',
                 connector_profile_properties: Optional['outputs.ConnectorProfileConnectorProfileProperties'] = None):
        """
        Connector specific configurations needed to create connector profile
        """
        pulumi.set(__self__, "connector_profile_credentials", connector_profile_credentials)
        if connector_profile_properties is not None:
            pulumi.set(__self__, "connector_profile_properties", connector_profile_properties)

    @property
    @pulumi.getter(name="connectorProfileCredentials")
    def connector_profile_credentials(self) -> 'outputs.ConnectorProfileConnectorProfileCredentials':
        return pulumi.get(self, "connector_profile_credentials")

    @property
    @pulumi.getter(name="connectorProfileProperties")
    def connector_profile_properties(self) -> Optional['outputs.ConnectorProfileConnectorProfileProperties']:
        return pulumi.get(self, "connector_profile_properties")


@pulumi.output_type
class ConnectorProfileConnectorProfileCredentials(dict):
    """
    Connector specific configuration needed to create connector profile based on Authentication mechanism
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "googleAnalytics":
            suggest = "google_analytics"
        elif key == "inforNexus":
            suggest = "infor_nexus"
        elif key == "serviceNow":
            suggest = "service_now"

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

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

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

    def __init__(__self__, *,
                 amplitude: Optional['outputs.ConnectorProfileAmplitudeConnectorProfileCredentials'] = None,
                 datadog: Optional['outputs.ConnectorProfileDatadogConnectorProfileCredentials'] = None,
                 dynatrace: Optional['outputs.ConnectorProfileDynatraceConnectorProfileCredentials'] = None,
                 google_analytics: Optional['outputs.ConnectorProfileGoogleAnalyticsConnectorProfileCredentials'] = None,
                 infor_nexus: Optional['outputs.ConnectorProfileInforNexusConnectorProfileCredentials'] = None,
                 marketo: Optional['outputs.ConnectorProfileMarketoConnectorProfileCredentials'] = None,
                 redshift: Optional['outputs.ConnectorProfileRedshiftConnectorProfileCredentials'] = None,
                 salesforce: Optional['outputs.ConnectorProfileSalesforceConnectorProfileCredentials'] = None,
                 service_now: Optional['outputs.ConnectorProfileServiceNowConnectorProfileCredentials'] = None,
                 singular: Optional['outputs.ConnectorProfileSingularConnectorProfileCredentials'] = None,
                 slack: Optional['outputs.ConnectorProfileSlackConnectorProfileCredentials'] = None,
                 snowflake: Optional['outputs.ConnectorProfileSnowflakeConnectorProfileCredentials'] = None,
                 trendmicro: Optional['outputs.ConnectorProfileTrendmicroConnectorProfileCredentials'] = None,
                 veeva: Optional['outputs.ConnectorProfileVeevaConnectorProfileCredentials'] = None,
                 zendesk: Optional['outputs.ConnectorProfileZendeskConnectorProfileCredentials'] = None):
        """
        Connector specific configuration needed to create connector profile based on Authentication mechanism
        """
        if amplitude is not None:
            pulumi.set(__self__, "amplitude", amplitude)
        if datadog is not None:
            pulumi.set(__self__, "datadog", datadog)
        if dynatrace is not None:
            pulumi.set(__self__, "dynatrace", dynatrace)
        if google_analytics is not None:
            pulumi.set(__self__, "google_analytics", google_analytics)
        if infor_nexus is not None:
            pulumi.set(__self__, "infor_nexus", infor_nexus)
        if marketo is not None:
            pulumi.set(__self__, "marketo", marketo)
        if redshift is not None:
            pulumi.set(__self__, "redshift", redshift)
        if salesforce is not None:
            pulumi.set(__self__, "salesforce", salesforce)
        if service_now is not None:
            pulumi.set(__self__, "service_now", service_now)
        if singular is not None:
            pulumi.set(__self__, "singular", singular)
        if slack is not None:
            pulumi.set(__self__, "slack", slack)
        if snowflake is not None:
            pulumi.set(__self__, "snowflake", snowflake)
        if trendmicro is not None:
            pulumi.set(__self__, "trendmicro", trendmicro)
        if veeva is not None:
            pulumi.set(__self__, "veeva", veeva)
        if zendesk is not None:
            pulumi.set(__self__, "zendesk", zendesk)

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

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

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

    @property
    @pulumi.getter(name="googleAnalytics")
    def google_analytics(self) -> Optional['outputs.ConnectorProfileGoogleAnalyticsConnectorProfileCredentials']:
        return pulumi.get(self, "google_analytics")

    @property
    @pulumi.getter(name="inforNexus")
    def infor_nexus(self) -> Optional['outputs.ConnectorProfileInforNexusConnectorProfileCredentials']:
        return pulumi.get(self, "infor_nexus")

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

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

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

    @property
    @pulumi.getter(name="serviceNow")
    def service_now(self) -> Optional['outputs.ConnectorProfileServiceNowConnectorProfileCredentials']:
        return pulumi.get(self, "service_now")

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

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

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

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

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

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


@pulumi.output_type
class ConnectorProfileConnectorProfileProperties(dict):
    """
    Connector specific properties needed to create connector profile - currently not needed for Amplitude, Trendmicro, Googleanalytics and Singular
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "inforNexus":
            suggest = "infor_nexus"
        elif key == "serviceNow":
            suggest = "service_now"

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

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

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

    def __init__(__self__, *,
                 datadog: Optional['outputs.ConnectorProfileDatadogConnectorProfileProperties'] = None,
                 dynatrace: Optional['outputs.ConnectorProfileDynatraceConnectorProfileProperties'] = None,
                 infor_nexus: Optional['outputs.ConnectorProfileInforNexusConnectorProfileProperties'] = None,
                 marketo: Optional['outputs.ConnectorProfileMarketoConnectorProfileProperties'] = None,
                 redshift: Optional['outputs.ConnectorProfileRedshiftConnectorProfileProperties'] = None,
                 salesforce: Optional['outputs.ConnectorProfileSalesforceConnectorProfileProperties'] = None,
                 service_now: Optional['outputs.ConnectorProfileServiceNowConnectorProfileProperties'] = None,
                 slack: Optional['outputs.ConnectorProfileSlackConnectorProfileProperties'] = None,
                 snowflake: Optional['outputs.ConnectorProfileSnowflakeConnectorProfileProperties'] = None,
                 veeva: Optional['outputs.ConnectorProfileVeevaConnectorProfileProperties'] = None,
                 zendesk: Optional['outputs.ConnectorProfileZendeskConnectorProfileProperties'] = None):
        """
        Connector specific properties needed to create connector profile - currently not needed for Amplitude, Trendmicro, Googleanalytics and Singular
        """
        if datadog is not None:
            pulumi.set(__self__, "datadog", datadog)
        if dynatrace is not None:
            pulumi.set(__self__, "dynatrace", dynatrace)
        if infor_nexus is not None:
            pulumi.set(__self__, "infor_nexus", infor_nexus)
        if marketo is not None:
            pulumi.set(__self__, "marketo", marketo)
        if redshift is not None:
            pulumi.set(__self__, "redshift", redshift)
        if salesforce is not None:
            pulumi.set(__self__, "salesforce", salesforce)
        if service_now is not None:
            pulumi.set(__self__, "service_now", service_now)
        if slack is not None:
            pulumi.set(__self__, "slack", slack)
        if snowflake is not None:
            pulumi.set(__self__, "snowflake", snowflake)
        if veeva is not None:
            pulumi.set(__self__, "veeva", veeva)
        if zendesk is not None:
            pulumi.set(__self__, "zendesk", zendesk)

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

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

    @property
    @pulumi.getter(name="inforNexus")
    def infor_nexus(self) -> Optional['outputs.ConnectorProfileInforNexusConnectorProfileProperties']:
        return pulumi.get(self, "infor_nexus")

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

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

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

    @property
    @pulumi.getter(name="serviceNow")
    def service_now(self) -> Optional['outputs.ConnectorProfileServiceNowConnectorProfileProperties']:
        return pulumi.get(self, "service_now")

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

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

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

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


@pulumi.output_type
class ConnectorProfileDatadogConnectorProfileCredentials(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "apiKey":
            suggest = "api_key"
        elif key == "applicationKey":
            suggest = "application_key"

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

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

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

    def __init__(__self__, *,
                 api_key: str,
                 application_key: str):
        """
        :param str api_key: A unique alphanumeric identiﬁer used to authenticate a user, developer, or calling program to your API.
        :param str application_key: Application keys, in conjunction with your API key, give you full access to Datadog’s programmatic API. Application keys are associated with the user account that created them. The application key is used to log all requests made to the API.
        """
        pulumi.set(__self__, "api_key", api_key)
        pulumi.set(__self__, "application_key", application_key)

    @property
    @pulumi.getter(name="apiKey")
    def api_key(self) -> str:
        """
        A unique alphanumeric identiﬁer used to authenticate a user, developer, or calling program to your API.
        """
        return pulumi.get(self, "api_key")

    @property
    @pulumi.getter(name="applicationKey")
    def application_key(self) -> str:
        """
        Application keys, in conjunction with your API key, give you full access to Datadog’s programmatic API. Application keys are associated with the user account that created them. The application key is used to log all requests made to the API.
        """
        return pulumi.get(self, "application_key")


@pulumi.output_type
class ConnectorProfileDatadogConnectorProfileProperties(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "instanceUrl":
            suggest = "instance_url"

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

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

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

    def __init__(__self__, *,
                 instance_url: str):
        """
        :param str instance_url: The location of the Datadog resource
        """
        pulumi.set(__self__, "instance_url", instance_url)

    @property
    @pulumi.getter(name="instanceUrl")
    def instance_url(self) -> str:
        """
        The location of the Datadog resource
        """
        return pulumi.get(self, "instance_url")


@pulumi.output_type
class ConnectorProfileDynatraceConnectorProfileCredentials(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "apiToken":
            suggest = "api_token"

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

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

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

    def __init__(__self__, *,
                 api_token: str):
        """
        :param str api_token: The API tokens used by Dynatrace API to authenticate various API calls.
        """
        pulumi.set(__self__, "api_token", api_token)

    @property
    @pulumi.getter(name="apiToken")
    def api_token(self) -> str:
        """
        The API tokens used by Dynatrace API to authenticate various API calls.
        """
        return pulumi.get(self, "api_token")


@pulumi.output_type
class ConnectorProfileDynatraceConnectorProfileProperties(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "instanceUrl":
            suggest = "instance_url"

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

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

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

    def __init__(__self__, *,
                 instance_url: str):
        """
        :param str instance_url: The location of the Dynatrace resource
        """
        pulumi.set(__self__, "instance_url", instance_url)

    @property
    @pulumi.getter(name="instanceUrl")
    def instance_url(self) -> str:
        """
        The location of the Dynatrace resource
        """
        return pulumi.get(self, "instance_url")


@pulumi.output_type
class ConnectorProfileGoogleAnalyticsConnectorProfileCredentials(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientId":
            suggest = "client_id"
        elif key == "clientSecret":
            suggest = "client_secret"
        elif key == "accessToken":
            suggest = "access_token"
        elif key == "connectorOAuthRequest":
            suggest = "connector_o_auth_request"
        elif key == "refreshToken":
            suggest = "refresh_token"

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

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

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

    def __init__(__self__, *,
                 client_id: str,
                 client_secret: str,
                 access_token: Optional[str] = None,
                 connector_o_auth_request: Optional['outputs.ConnectorProfileConnectorOAuthRequest'] = None,
                 refresh_token: Optional[str] = None):
        """
        :param str client_id: The identiﬁer for the desired client.
        :param str client_secret: The client secret used by the oauth client to authenticate to the authorization server.
        :param str access_token: The credentials used to access protected resources.
        :param 'ConnectorProfileConnectorOAuthRequest' connector_o_auth_request: The oauth needed to request security tokens from the connector endpoint.
        :param str refresh_token: The credentials used to acquire new access tokens.
        """
        pulumi.set(__self__, "client_id", client_id)
        pulumi.set(__self__, "client_secret", client_secret)
        if access_token is not None:
            pulumi.set(__self__, "access_token", access_token)
        if connector_o_auth_request is not None:
            pulumi.set(__self__, "connector_o_auth_request", connector_o_auth_request)
        if refresh_token is not None:
            pulumi.set(__self__, "refresh_token", refresh_token)

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> str:
        """
        The identiﬁer for the desired client.
        """
        return pulumi.get(self, "client_id")

    @property
    @pulumi.getter(name="clientSecret")
    def client_secret(self) -> str:
        """
        The client secret used by the oauth client to authenticate to the authorization server.
        """
        return pulumi.get(self, "client_secret")

    @property
    @pulumi.getter(name="accessToken")
    def access_token(self) -> Optional[str]:
        """
        The credentials used to access protected resources.
        """
        return pulumi.get(self, "access_token")

    @property
    @pulumi.getter(name="connectorOAuthRequest")
    def connector_o_auth_request(self) -> Optional['outputs.ConnectorProfileConnectorOAuthRequest']:
        """
        The oauth needed to request security tokens from the connector endpoint.
        """
        return pulumi.get(self, "connector_o_auth_request")

    @property
    @pulumi.getter(name="refreshToken")
    def refresh_token(self) -> Optional[str]:
        """
        The credentials used to acquire new access tokens.
        """
        return pulumi.get(self, "refresh_token")


@pulumi.output_type
class ConnectorProfileInforNexusConnectorProfileCredentials(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessKeyId":
            suggest = "access_key_id"
        elif key == "secretAccessKey":
            suggest = "secret_access_key"
        elif key == "userId":
            suggest = "user_id"

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

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

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

    def __init__(__self__, *,
                 access_key_id: str,
                 datakey: str,
                 secret_access_key: str,
                 user_id: str):
        """
        :param str access_key_id: The Access Key portion of the credentials.
        :param str datakey: The encryption keys used to encrypt data.
        :param str secret_access_key: The secret key used to sign requests.
        :param str user_id: The identiﬁer for the user.
        """
        pulumi.set(__self__, "access_key_id", access_key_id)
        pulumi.set(__self__, "datakey", datakey)
        pulumi.set(__self__, "secret_access_key", secret_access_key)
        pulumi.set(__self__, "user_id", user_id)

    @property
    @pulumi.getter(name="accessKeyId")
    def access_key_id(self) -> str:
        """
        The Access Key portion of the credentials.
        """
        return pulumi.get(self, "access_key_id")

    @property
    @pulumi.getter
    def datakey(self) -> str:
        """
        The encryption keys used to encrypt data.
        """
        return pulumi.get(self, "datakey")

    @property
    @pulumi.getter(name="secretAccessKey")
    def secret_access_key(self) -> str:
        """
        The secret key used to sign requests.
        """
        return pulumi.get(self, "secret_access_key")

    @property
    @pulumi.getter(name="userId")
    def user_id(self) -> str:
        """
        The identiﬁer for the user.
        """
        return pulumi.get(self, "user_id")


@pulumi.output_type
class ConnectorProfileInforNexusConnectorProfileProperties(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "instanceUrl":
            suggest = "instance_url"

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

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

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

    def __init__(__self__, *,
                 instance_url: str):
        """
        :param str instance_url: The location of the InforNexus resource
        """
        pulumi.set(__self__, "instance_url", instance_url)

    @property
    @pulumi.getter(name="instanceUrl")
    def instance_url(self) -> str:
        """
        The location of the InforNexus resource
        """
        return pulumi.get(self, "instance_url")


@pulumi.output_type
class ConnectorProfileMarketoConnectorProfileCredentials(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientId":
            suggest = "client_id"
        elif key == "clientSecret":
            suggest = "client_secret"
        elif key == "accessToken":
            suggest = "access_token"
        elif key == "connectorOAuthRequest":
            suggest = "connector_o_auth_request"

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

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

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

    def __init__(__self__, *,
                 client_id: str,
                 client_secret: str,
                 access_token: Optional[str] = None,
                 connector_o_auth_request: Optional['outputs.ConnectorProfileConnectorOAuthRequest'] = None):
        """
        :param str client_id: The identiﬁer for the desired client.
        :param str client_secret: The client secret used by the oauth client to authenticate to the authorization server.
        :param str access_token: The credentials used to access protected resources.
        :param 'ConnectorProfileConnectorOAuthRequest' connector_o_auth_request: The oauth needed to request security tokens from the connector endpoint.
        """
        pulumi.set(__self__, "client_id", client_id)
        pulumi.set(__self__, "client_secret", client_secret)
        if access_token is not None:
            pulumi.set(__self__, "access_token", access_token)
        if connector_o_auth_request is not None:
            pulumi.set(__self__, "connector_o_auth_request", connector_o_auth_request)

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> str:
        """
        The identiﬁer for the desired client.
        """
        return pulumi.get(self, "client_id")

    @property
    @pulumi.getter(name="clientSecret")
    def client_secret(self) -> str:
        """
        The client secret used by the oauth client to authenticate to the authorization server.
        """
        return pulumi.get(self, "client_secret")

    @property
    @pulumi.getter(name="accessToken")
    def access_token(self) -> Optional[str]:
        """
        The credentials used to access protected resources.
        """
        return pulumi.get(self, "access_token")

    @property
    @pulumi.getter(name="connectorOAuthRequest")
    def connector_o_auth_request(self) -> Optional['outputs.ConnectorProfileConnectorOAuthRequest']:
        """
        The oauth needed to request security tokens from the connector endpoint.
        """
        return pulumi.get(self, "connector_o_auth_request")


@pulumi.output_type
class ConnectorProfileMarketoConnectorProfileProperties(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "instanceUrl":
            suggest = "instance_url"

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

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

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

    def __init__(__self__, *,
                 instance_url: str):
        """
        :param str instance_url: The location of the Marketo resource
        """
        pulumi.set(__self__, "instance_url", instance_url)

    @property
    @pulumi.getter(name="instanceUrl")
    def instance_url(self) -> str:
        """
        The location of the Marketo resource
        """
        return pulumi.get(self, "instance_url")


@pulumi.output_type
class ConnectorProfileRedshiftConnectorProfileCredentials(dict):
    def __init__(__self__, *,
                 password: str,
                 username: str):
        """
        :param str password: The password that corresponds to the username.
        :param str username: The name of the user.
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The password that corresponds to the username.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The name of the user.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class ConnectorProfileRedshiftConnectorProfileProperties(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bucketName":
            suggest = "bucket_name"
        elif key == "databaseUrl":
            suggest = "database_url"
        elif key == "roleArn":
            suggest = "role_arn"
        elif key == "bucketPrefix":
            suggest = "bucket_prefix"

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

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

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

    def __init__(__self__, *,
                 bucket_name: str,
                 database_url: str,
                 role_arn: str,
                 bucket_prefix: Optional[str] = None):
        """
        :param str bucket_name: The name of the Amazon S3 bucket associated with Redshift.
        :param str database_url: The JDBC URL of the Amazon Redshift cluster.
        :param str role_arn: The Amazon Resource Name (ARN) of the IAM role.
        :param str bucket_prefix: The object key for the destination bucket in which Amazon AppFlow will place the ﬁles.
        """
        pulumi.set(__self__, "bucket_name", bucket_name)
        pulumi.set(__self__, "database_url", database_url)
        pulumi.set(__self__, "role_arn", role_arn)
        if bucket_prefix is not None:
            pulumi.set(__self__, "bucket_prefix", bucket_prefix)

    @property
    @pulumi.getter(name="bucketName")
    def bucket_name(self) -> str:
        """
        The name of the Amazon S3 bucket associated with Redshift.
        """
        return pulumi.get(self, "bucket_name")

    @property
    @pulumi.getter(name="databaseUrl")
    def database_url(self) -> str:
        """
        The JDBC URL of the Amazon Redshift cluster.
        """
        return pulumi.get(self, "database_url")

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        """
        The Amazon Resource Name (ARN) of the IAM role.
        """
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter(name="bucketPrefix")
    def bucket_prefix(self) -> Optional[str]:
        """
        The object key for the destination bucket in which Amazon AppFlow will place the ﬁles.
        """
        return pulumi.get(self, "bucket_prefix")


@pulumi.output_type
class ConnectorProfileSalesforceConnectorProfileCredentials(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessToken":
            suggest = "access_token"
        elif key == "clientCredentialsArn":
            suggest = "client_credentials_arn"
        elif key == "connectorOAuthRequest":
            suggest = "connector_o_auth_request"
        elif key == "refreshToken":
            suggest = "refresh_token"

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

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

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

    def __init__(__self__, *,
                 access_token: Optional[str] = None,
                 client_credentials_arn: Optional[str] = None,
                 connector_o_auth_request: Optional['outputs.ConnectorProfileConnectorOAuthRequest'] = None,
                 refresh_token: Optional[str] = None):
        """
        :param str access_token: The credentials used to access protected resources.
        :param str client_credentials_arn: The client credentials to fetch access token and refresh token.
        :param 'ConnectorProfileConnectorOAuthRequest' connector_o_auth_request: The oauth needed to request security tokens from the connector endpoint.
        :param str refresh_token: The credentials used to acquire new access tokens.
        """
        if access_token is not None:
            pulumi.set(__self__, "access_token", access_token)
        if client_credentials_arn is not None:
            pulumi.set(__self__, "client_credentials_arn", client_credentials_arn)
        if connector_o_auth_request is not None:
            pulumi.set(__self__, "connector_o_auth_request", connector_o_auth_request)
        if refresh_token is not None:
            pulumi.set(__self__, "refresh_token", refresh_token)

    @property
    @pulumi.getter(name="accessToken")
    def access_token(self) -> Optional[str]:
        """
        The credentials used to access protected resources.
        """
        return pulumi.get(self, "access_token")

    @property
    @pulumi.getter(name="clientCredentialsArn")
    def client_credentials_arn(self) -> Optional[str]:
        """
        The client credentials to fetch access token and refresh token.
        """
        return pulumi.get(self, "client_credentials_arn")

    @property
    @pulumi.getter(name="connectorOAuthRequest")
    def connector_o_auth_request(self) -> Optional['outputs.ConnectorProfileConnectorOAuthRequest']:
        """
        The oauth needed to request security tokens from the connector endpoint.
        """
        return pulumi.get(self, "connector_o_auth_request")

    @property
    @pulumi.getter(name="refreshToken")
    def refresh_token(self) -> Optional[str]:
        """
        The credentials used to acquire new access tokens.
        """
        return pulumi.get(self, "refresh_token")


@pulumi.output_type
class ConnectorProfileSalesforceConnectorProfileProperties(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "instanceUrl":
            suggest = "instance_url"
        elif key == "isSandboxEnvironment":
            suggest = "is_sandbox_environment"

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

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

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

    def __init__(__self__, *,
                 instance_url: Optional[str] = None,
                 is_sandbox_environment: Optional[bool] = None):
        """
        :param str instance_url: The location of the Salesforce resource
        """
        if instance_url is not None:
            pulumi.set(__self__, "instance_url", instance_url)
        if is_sandbox_environment is not None:
            pulumi.set(__self__, "is_sandbox_environment", is_sandbox_environment)

    @property
    @pulumi.getter(name="instanceUrl")
    def instance_url(self) -> Optional[str]:
        """
        The location of the Salesforce resource
        """
        return pulumi.get(self, "instance_url")

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


@pulumi.output_type
class ConnectorProfileServiceNowConnectorProfileCredentials(dict):
    def __init__(__self__, *,
                 password: str,
                 username: str):
        """
        :param str password: The password that corresponds to the username.
        :param str username: The name of the user.
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The password that corresponds to the username.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The name of the user.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class ConnectorProfileServiceNowConnectorProfileProperties(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "instanceUrl":
            suggest = "instance_url"

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

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

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

    def __init__(__self__, *,
                 instance_url: str):
        """
        :param str instance_url: The location of the ServiceNow resource
        """
        pulumi.set(__self__, "instance_url", instance_url)

    @property
    @pulumi.getter(name="instanceUrl")
    def instance_url(self) -> str:
        """
        The location of the ServiceNow resource
        """
        return pulumi.get(self, "instance_url")


@pulumi.output_type
class ConnectorProfileSingularConnectorProfileCredentials(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "apiKey":
            suggest = "api_key"

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

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

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

    def __init__(__self__, *,
                 api_key: str):
        """
        :param str api_key: A unique alphanumeric identiﬁer used to authenticate a user, developer, or calling program to your API.
        """
        pulumi.set(__self__, "api_key", api_key)

    @property
    @pulumi.getter(name="apiKey")
    def api_key(self) -> str:
        """
        A unique alphanumeric identiﬁer used to authenticate a user, developer, or calling program to your API.
        """
        return pulumi.get(self, "api_key")


@pulumi.output_type
class ConnectorProfileSlackConnectorProfileCredentials(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientId":
            suggest = "client_id"
        elif key == "clientSecret":
            suggest = "client_secret"
        elif key == "accessToken":
            suggest = "access_token"
        elif key == "connectorOAuthRequest":
            suggest = "connector_o_auth_request"

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

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

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

    def __init__(__self__, *,
                 client_id: str,
                 client_secret: str,
                 access_token: Optional[str] = None,
                 connector_o_auth_request: Optional['outputs.ConnectorProfileConnectorOAuthRequest'] = None):
        """
        :param str client_id: The identiﬁer for the desired client.
        :param str client_secret: The client secret used by the oauth client to authenticate to the authorization server.
        :param str access_token: The credentials used to access protected resources.
        :param 'ConnectorProfileConnectorOAuthRequest' connector_o_auth_request: The oauth needed to request security tokens from the connector endpoint.
        """
        pulumi.set(__self__, "client_id", client_id)
        pulumi.set(__self__, "client_secret", client_secret)
        if access_token is not None:
            pulumi.set(__self__, "access_token", access_token)
        if connector_o_auth_request is not None:
            pulumi.set(__self__, "connector_o_auth_request", connector_o_auth_request)

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> str:
        """
        The identiﬁer for the desired client.
        """
        return pulumi.get(self, "client_id")

    @property
    @pulumi.getter(name="clientSecret")
    def client_secret(self) -> str:
        """
        The client secret used by the oauth client to authenticate to the authorization server.
        """
        return pulumi.get(self, "client_secret")

    @property
    @pulumi.getter(name="accessToken")
    def access_token(self) -> Optional[str]:
        """
        The credentials used to access protected resources.
        """
        return pulumi.get(self, "access_token")

    @property
    @pulumi.getter(name="connectorOAuthRequest")
    def connector_o_auth_request(self) -> Optional['outputs.ConnectorProfileConnectorOAuthRequest']:
        """
        The oauth needed to request security tokens from the connector endpoint.
        """
        return pulumi.get(self, "connector_o_auth_request")


@pulumi.output_type
class ConnectorProfileSlackConnectorProfileProperties(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "instanceUrl":
            suggest = "instance_url"

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

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

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

    def __init__(__self__, *,
                 instance_url: str):
        """
        :param str instance_url: The location of the Slack resource
        """
        pulumi.set(__self__, "instance_url", instance_url)

    @property
    @pulumi.getter(name="instanceUrl")
    def instance_url(self) -> str:
        """
        The location of the Slack resource
        """
        return pulumi.get(self, "instance_url")


@pulumi.output_type
class ConnectorProfileSnowflakeConnectorProfileCredentials(dict):
    def __init__(__self__, *,
                 password: str,
                 username: str):
        """
        :param str password: The password that corresponds to the username.
        :param str username: The name of the user.
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The password that corresponds to the username.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The name of the user.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class ConnectorProfileSnowflakeConnectorProfileProperties(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bucketName":
            suggest = "bucket_name"
        elif key == "accountName":
            suggest = "account_name"
        elif key == "bucketPrefix":
            suggest = "bucket_prefix"
        elif key == "privateLinkServiceName":
            suggest = "private_link_service_name"

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

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

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

    def __init__(__self__, *,
                 bucket_name: str,
                 stage: str,
                 warehouse: str,
                 account_name: Optional[str] = None,
                 bucket_prefix: Optional[str] = None,
                 private_link_service_name: Optional[str] = None,
                 region: Optional[str] = None):
        """
        :param str bucket_name: The name of the Amazon S3 bucket associated with Snowﬂake.
        :param str stage: The name of the Amazon S3 stage that was created while setting up an Amazon S3 stage in the
               Snowﬂake account. This is written in the following format: < Database>< Schema><Stage Name>.
        :param str warehouse: The name of the Snowﬂake warehouse.
        :param str account_name: The name of the account.
        :param str bucket_prefix: The bucket prefix that refers to the Amazon S3 bucket associated with Snowﬂake.
        :param str private_link_service_name: The Snowﬂake Private Link service name to be used for private data transfers.
        :param str region: The region of the Snowﬂake account.
        """
        pulumi.set(__self__, "bucket_name", bucket_name)
        pulumi.set(__self__, "stage", stage)
        pulumi.set(__self__, "warehouse", warehouse)
        if account_name is not None:
            pulumi.set(__self__, "account_name", account_name)
        if bucket_prefix is not None:
            pulumi.set(__self__, "bucket_prefix", bucket_prefix)
        if private_link_service_name is not None:
            pulumi.set(__self__, "private_link_service_name", private_link_service_name)
        if region is not None:
            pulumi.set(__self__, "region", region)

    @property
    @pulumi.getter(name="bucketName")
    def bucket_name(self) -> str:
        """
        The name of the Amazon S3 bucket associated with Snowﬂake.
        """
        return pulumi.get(self, "bucket_name")

    @property
    @pulumi.getter
    def stage(self) -> str:
        """
        The name of the Amazon S3 stage that was created while setting up an Amazon S3 stage in the
        Snowﬂake account. This is written in the following format: < Database>< Schema><Stage Name>.
        """
        return pulumi.get(self, "stage")

    @property
    @pulumi.getter
    def warehouse(self) -> str:
        """
        The name of the Snowﬂake warehouse.
        """
        return pulumi.get(self, "warehouse")

    @property
    @pulumi.getter(name="accountName")
    def account_name(self) -> Optional[str]:
        """
        The name of the account.
        """
        return pulumi.get(self, "account_name")

    @property
    @pulumi.getter(name="bucketPrefix")
    def bucket_prefix(self) -> Optional[str]:
        """
        The bucket prefix that refers to the Amazon S3 bucket associated with Snowﬂake.
        """
        return pulumi.get(self, "bucket_prefix")

    @property
    @pulumi.getter(name="privateLinkServiceName")
    def private_link_service_name(self) -> Optional[str]:
        """
        The Snowﬂake Private Link service name to be used for private data transfers.
        """
        return pulumi.get(self, "private_link_service_name")

    @property
    @pulumi.getter
    def region(self) -> Optional[str]:
        """
        The region of the Snowﬂake account.
        """
        return pulumi.get(self, "region")


@pulumi.output_type
class ConnectorProfileTrendmicroConnectorProfileCredentials(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "apiSecretKey":
            suggest = "api_secret_key"

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

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

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

    def __init__(__self__, *,
                 api_secret_key: str):
        """
        :param str api_secret_key: The Secret Access Key portion of the credentials.
        """
        pulumi.set(__self__, "api_secret_key", api_secret_key)

    @property
    @pulumi.getter(name="apiSecretKey")
    def api_secret_key(self) -> str:
        """
        The Secret Access Key portion of the credentials.
        """
        return pulumi.get(self, "api_secret_key")


@pulumi.output_type
class ConnectorProfileVeevaConnectorProfileCredentials(dict):
    def __init__(__self__, *,
                 password: str,
                 username: str):
        """
        :param str password: The password that corresponds to the username.
        :param str username: The name of the user.
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The password that corresponds to the username.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The name of the user.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class ConnectorProfileVeevaConnectorProfileProperties(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "instanceUrl":
            suggest = "instance_url"

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

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

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

    def __init__(__self__, *,
                 instance_url: str):
        """
        :param str instance_url: The location of the Veeva resource
        """
        pulumi.set(__self__, "instance_url", instance_url)

    @property
    @pulumi.getter(name="instanceUrl")
    def instance_url(self) -> str:
        """
        The location of the Veeva resource
        """
        return pulumi.get(self, "instance_url")


@pulumi.output_type
class ConnectorProfileZendeskConnectorProfileCredentials(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientId":
            suggest = "client_id"
        elif key == "clientSecret":
            suggest = "client_secret"
        elif key == "accessToken":
            suggest = "access_token"
        elif key == "connectorOAuthRequest":
            suggest = "connector_o_auth_request"

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

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

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

    def __init__(__self__, *,
                 client_id: str,
                 client_secret: str,
                 access_token: Optional[str] = None,
                 connector_o_auth_request: Optional['outputs.ConnectorProfileConnectorOAuthRequest'] = None):
        """
        :param str client_id: The identiﬁer for the desired client.
        :param str client_secret: The client secret used by the oauth client to authenticate to the authorization server.
        :param str access_token: The credentials used to access protected resources.
        :param 'ConnectorProfileConnectorOAuthRequest' connector_o_auth_request: The oauth needed to request security tokens from the connector endpoint.
        """
        pulumi.set(__self__, "client_id", client_id)
        pulumi.set(__self__, "client_secret", client_secret)
        if access_token is not None:
            pulumi.set(__self__, "access_token", access_token)
        if connector_o_auth_request is not None:
            pulumi.set(__self__, "connector_o_auth_request", connector_o_auth_request)

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> str:
        """
        The identiﬁer for the desired client.
        """
        return pulumi.get(self, "client_id")

    @property
    @pulumi.getter(name="clientSecret")
    def client_secret(self) -> str:
        """
        The client secret used by the oauth client to authenticate to the authorization server.
        """
        return pulumi.get(self, "client_secret")

    @property
    @pulumi.getter(name="accessToken")
    def access_token(self) -> Optional[str]:
        """
        The credentials used to access protected resources.
        """
        return pulumi.get(self, "access_token")

    @property
    @pulumi.getter(name="connectorOAuthRequest")
    def connector_o_auth_request(self) -> Optional['outputs.ConnectorProfileConnectorOAuthRequest']:
        """
        The oauth needed to request security tokens from the connector endpoint.
        """
        return pulumi.get(self, "connector_o_auth_request")


@pulumi.output_type
class ConnectorProfileZendeskConnectorProfileProperties(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "instanceUrl":
            suggest = "instance_url"

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

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

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

    def __init__(__self__, *,
                 instance_url: str):
        """
        :param str instance_url: The location of the Zendesk resource
        """
        pulumi.set(__self__, "instance_url", instance_url)

    @property
    @pulumi.getter(name="instanceUrl")
    def instance_url(self) -> str:
        """
        The location of the Zendesk resource
        """
        return pulumi.get(self, "instance_url")


@pulumi.output_type
class FlowAggregationConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "aggregationType":
            suggest = "aggregation_type"

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

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

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

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

    @property
    @pulumi.getter(name="aggregationType")
    def aggregation_type(self) -> Optional['FlowAggregationType']:
        return pulumi.get(self, "aggregation_type")


@pulumi.output_type
class FlowAmplitudeSourceProperties(dict):
    def __init__(__self__, *,
                 object: str):
        pulumi.set(__self__, "object", object)

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


@pulumi.output_type
class FlowConnectorOperator(dict):
    """
    Operation to be performed on provided source fields
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "googleAnalytics":
            suggest = "google_analytics"
        elif key == "inforNexus":
            suggest = "infor_nexus"
        elif key == "serviceNow":
            suggest = "service_now"

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

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

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

    def __init__(__self__, *,
                 amplitude: Optional['FlowAmplitudeConnectorOperator'] = None,
                 datadog: Optional['FlowDatadogConnectorOperator'] = None,
                 dynatrace: Optional['FlowDynatraceConnectorOperator'] = None,
                 google_analytics: Optional['FlowGoogleAnalyticsConnectorOperator'] = None,
                 infor_nexus: Optional['FlowInforNexusConnectorOperator'] = None,
                 marketo: Optional['FlowMarketoConnectorOperator'] = None,
                 s3: Optional['FlowS3ConnectorOperator'] = None,
                 salesforce: Optional['FlowSalesforceConnectorOperator'] = None,
                 service_now: Optional['FlowServiceNowConnectorOperator'] = None,
                 singular: Optional['FlowSingularConnectorOperator'] = None,
                 slack: Optional['FlowSlackConnectorOperator'] = None,
                 trendmicro: Optional['FlowTrendmicroConnectorOperator'] = None,
                 veeva: Optional['FlowVeevaConnectorOperator'] = None,
                 zendesk: Optional['FlowZendeskConnectorOperator'] = None):
        """
        Operation to be performed on provided source fields
        """
        if amplitude is not None:
            pulumi.set(__self__, "amplitude", amplitude)
        if datadog is not None:
            pulumi.set(__self__, "datadog", datadog)
        if dynatrace is not None:
            pulumi.set(__self__, "dynatrace", dynatrace)
        if google_analytics is not None:
            pulumi.set(__self__, "google_analytics", google_analytics)
        if infor_nexus is not None:
            pulumi.set(__self__, "infor_nexus", infor_nexus)
        if marketo is not None:
            pulumi.set(__self__, "marketo", marketo)
        if s3 is not None:
            pulumi.set(__self__, "s3", s3)
        if salesforce is not None:
            pulumi.set(__self__, "salesforce", salesforce)
        if service_now is not None:
            pulumi.set(__self__, "service_now", service_now)
        if singular is not None:
            pulumi.set(__self__, "singular", singular)
        if slack is not None:
            pulumi.set(__self__, "slack", slack)
        if trendmicro is not None:
            pulumi.set(__self__, "trendmicro", trendmicro)
        if veeva is not None:
            pulumi.set(__self__, "veeva", veeva)
        if zendesk is not None:
            pulumi.set(__self__, "zendesk", zendesk)

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

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

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

    @property
    @pulumi.getter(name="googleAnalytics")
    def google_analytics(self) -> Optional['FlowGoogleAnalyticsConnectorOperator']:
        return pulumi.get(self, "google_analytics")

    @property
    @pulumi.getter(name="inforNexus")
    def infor_nexus(self) -> Optional['FlowInforNexusConnectorOperator']:
        return pulumi.get(self, "infor_nexus")

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

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

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

    @property
    @pulumi.getter(name="serviceNow")
    def service_now(self) -> Optional['FlowServiceNowConnectorOperator']:
        return pulumi.get(self, "service_now")

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

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

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

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

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


@pulumi.output_type
class FlowDatadogSourceProperties(dict):
    def __init__(__self__, *,
                 object: str):
        pulumi.set(__self__, "object", object)

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


@pulumi.output_type
class FlowDestinationConnectorProperties(dict):
    """
    Destination connector details
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "eventBridge":
            suggest = "event_bridge"
        elif key == "lookoutMetrics":
            suggest = "lookout_metrics"

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

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

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

    def __init__(__self__, *,
                 event_bridge: Optional['outputs.FlowEventBridgeDestinationProperties'] = None,
                 lookout_metrics: Optional['outputs.FlowLookoutMetricsDestinationProperties'] = None,
                 redshift: Optional['outputs.FlowRedshiftDestinationProperties'] = None,
                 s3: Optional['outputs.FlowS3DestinationProperties'] = None,
                 salesforce: Optional['outputs.FlowSalesforceDestinationProperties'] = None,
                 snowflake: Optional['outputs.FlowSnowflakeDestinationProperties'] = None,
                 upsolver: Optional['outputs.FlowUpsolverDestinationProperties'] = None,
                 zendesk: Optional['outputs.FlowZendeskDestinationProperties'] = None):
        """
        Destination connector details
        """
        if event_bridge is not None:
            pulumi.set(__self__, "event_bridge", event_bridge)
        if lookout_metrics is not None:
            pulumi.set(__self__, "lookout_metrics", lookout_metrics)
        if redshift is not None:
            pulumi.set(__self__, "redshift", redshift)
        if s3 is not None:
            pulumi.set(__self__, "s3", s3)
        if salesforce is not None:
            pulumi.set(__self__, "salesforce", salesforce)
        if snowflake is not None:
            pulumi.set(__self__, "snowflake", snowflake)
        if upsolver is not None:
            pulumi.set(__self__, "upsolver", upsolver)
        if zendesk is not None:
            pulumi.set(__self__, "zendesk", zendesk)

    @property
    @pulumi.getter(name="eventBridge")
    def event_bridge(self) -> Optional['outputs.FlowEventBridgeDestinationProperties']:
        return pulumi.get(self, "event_bridge")

    @property
    @pulumi.getter(name="lookoutMetrics")
    def lookout_metrics(self) -> Optional['outputs.FlowLookoutMetricsDestinationProperties']:
        return pulumi.get(self, "lookout_metrics")

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

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

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

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

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

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


@pulumi.output_type
class FlowDestinationFlowConfig(dict):
    """
    Configurations of destination connector.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "connectorType":
            suggest = "connector_type"
        elif key == "destinationConnectorProperties":
            suggest = "destination_connector_properties"
        elif key == "connectorProfileName":
            suggest = "connector_profile_name"

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

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

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

    def __init__(__self__, *,
                 connector_type: 'FlowConnectorType',
                 destination_connector_properties: 'outputs.FlowDestinationConnectorProperties',
                 connector_profile_name: Optional[str] = None):
        """
        Configurations of destination connector.
        :param 'FlowConnectorType' connector_type: Destination connector type
        :param 'FlowDestinationConnectorProperties' destination_connector_properties: Destination connector details
        :param str connector_profile_name: Name of destination connector profile
        """
        pulumi.set(__self__, "connector_type", connector_type)
        pulumi.set(__self__, "destination_connector_properties", destination_connector_properties)
        if connector_profile_name is not None:
            pulumi.set(__self__, "connector_profile_name", connector_profile_name)

    @property
    @pulumi.getter(name="connectorType")
    def connector_type(self) -> 'FlowConnectorType':
        """
        Destination connector type
        """
        return pulumi.get(self, "connector_type")

    @property
    @pulumi.getter(name="destinationConnectorProperties")
    def destination_connector_properties(self) -> 'outputs.FlowDestinationConnectorProperties':
        """
        Destination connector details
        """
        return pulumi.get(self, "destination_connector_properties")

    @property
    @pulumi.getter(name="connectorProfileName")
    def connector_profile_name(self) -> Optional[str]:
        """
        Name of destination connector profile
        """
        return pulumi.get(self, "connector_profile_name")


@pulumi.output_type
class FlowDynatraceSourceProperties(dict):
    def __init__(__self__, *,
                 object: str):
        pulumi.set(__self__, "object", object)

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


@pulumi.output_type
class FlowErrorHandlingConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bucketName":
            suggest = "bucket_name"
        elif key == "bucketPrefix":
            suggest = "bucket_prefix"
        elif key == "failOnFirstError":
            suggest = "fail_on_first_error"

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

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

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

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

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

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

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


@pulumi.output_type
class FlowEventBridgeDestinationProperties(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "errorHandlingConfig":
            suggest = "error_handling_config"

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

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

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

    def __init__(__self__, *,
                 object: str,
                 error_handling_config: Optional['outputs.FlowErrorHandlingConfig'] = None):
        pulumi.set(__self__, "object", object)
        if error_handling_config is not None:
            pulumi.set(__self__, "error_handling_config", error_handling_config)

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

    @property
    @pulumi.getter(name="errorHandlingConfig")
    def error_handling_config(self) -> Optional['outputs.FlowErrorHandlingConfig']:
        return pulumi.get(self, "error_handling_config")


@pulumi.output_type
class FlowGoogleAnalyticsSourceProperties(dict):
    def __init__(__self__, *,
                 object: str):
        pulumi.set(__self__, "object", object)

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


@pulumi.output_type
class FlowIncrementalPullConfig(dict):
    """
    Configuration for scheduled incremental data pull
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "datetimeTypeFieldName":
            suggest = "datetime_type_field_name"

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

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

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

    def __init__(__self__, *,
                 datetime_type_field_name: Optional[str] = None):
        """
        Configuration for scheduled incremental data pull
        """
        if datetime_type_field_name is not None:
            pulumi.set(__self__, "datetime_type_field_name", datetime_type_field_name)

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


@pulumi.output_type
class FlowInforNexusSourceProperties(dict):
    def __init__(__self__, *,
                 object: str):
        pulumi.set(__self__, "object", object)

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


@pulumi.output_type
class FlowLookoutMetricsDestinationProperties(dict):
    def __init__(__self__, *,
                 object: Optional[str] = None):
        if object is not None:
            pulumi.set(__self__, "object", object)

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


@pulumi.output_type
class FlowMarketoSourceProperties(dict):
    def __init__(__self__, *,
                 object: str):
        pulumi.set(__self__, "object", object)

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


@pulumi.output_type
class FlowPrefixConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "prefixFormat":
            suggest = "prefix_format"
        elif key == "prefixType":
            suggest = "prefix_type"

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

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

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

    def __init__(__self__, *,
                 prefix_format: Optional['FlowPrefixFormat'] = None,
                 prefix_type: Optional['FlowPrefixType'] = None):
        if prefix_format is not None:
            pulumi.set(__self__, "prefix_format", prefix_format)
        if prefix_type is not None:
            pulumi.set(__self__, "prefix_type", prefix_type)

    @property
    @pulumi.getter(name="prefixFormat")
    def prefix_format(self) -> Optional['FlowPrefixFormat']:
        return pulumi.get(self, "prefix_format")

    @property
    @pulumi.getter(name="prefixType")
    def prefix_type(self) -> Optional['FlowPrefixType']:
        return pulumi.get(self, "prefix_type")


@pulumi.output_type
class FlowRedshiftDestinationProperties(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "intermediateBucketName":
            suggest = "intermediate_bucket_name"
        elif key == "bucketPrefix":
            suggest = "bucket_prefix"
        elif key == "errorHandlingConfig":
            suggest = "error_handling_config"

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

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

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

    def __init__(__self__, *,
                 intermediate_bucket_name: str,
                 object: str,
                 bucket_prefix: Optional[str] = None,
                 error_handling_config: Optional['outputs.FlowErrorHandlingConfig'] = None):
        pulumi.set(__self__, "intermediate_bucket_name", intermediate_bucket_name)
        pulumi.set(__self__, "object", object)
        if bucket_prefix is not None:
            pulumi.set(__self__, "bucket_prefix", bucket_prefix)
        if error_handling_config is not None:
            pulumi.set(__self__, "error_handling_config", error_handling_config)

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

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

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

    @property
    @pulumi.getter(name="errorHandlingConfig")
    def error_handling_config(self) -> Optional['outputs.FlowErrorHandlingConfig']:
        return pulumi.get(self, "error_handling_config")


@pulumi.output_type
class FlowS3DestinationProperties(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bucketName":
            suggest = "bucket_name"
        elif key == "bucketPrefix":
            suggest = "bucket_prefix"
        elif key == "s3OutputFormatConfig":
            suggest = "s3_output_format_config"

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

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

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

    def __init__(__self__, *,
                 bucket_name: str,
                 bucket_prefix: Optional[str] = None,
                 s3_output_format_config: Optional['outputs.FlowS3OutputFormatConfig'] = None):
        pulumi.set(__self__, "bucket_name", bucket_name)
        if bucket_prefix is not None:
            pulumi.set(__self__, "bucket_prefix", bucket_prefix)
        if s3_output_format_config is not None:
            pulumi.set(__self__, "s3_output_format_config", s3_output_format_config)

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

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

    @property
    @pulumi.getter(name="s3OutputFormatConfig")
    def s3_output_format_config(self) -> Optional['outputs.FlowS3OutputFormatConfig']:
        return pulumi.get(self, "s3_output_format_config")


@pulumi.output_type
class FlowS3OutputFormatConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "aggregationConfig":
            suggest = "aggregation_config"
        elif key == "fileType":
            suggest = "file_type"
        elif key == "prefixConfig":
            suggest = "prefix_config"

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

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

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

    def __init__(__self__, *,
                 aggregation_config: Optional['outputs.FlowAggregationConfig'] = None,
                 file_type: Optional['FlowFileType'] = None,
                 prefix_config: Optional['outputs.FlowPrefixConfig'] = None):
        if aggregation_config is not None:
            pulumi.set(__self__, "aggregation_config", aggregation_config)
        if file_type is not None:
            pulumi.set(__self__, "file_type", file_type)
        if prefix_config is not None:
            pulumi.set(__self__, "prefix_config", prefix_config)

    @property
    @pulumi.getter(name="aggregationConfig")
    def aggregation_config(self) -> Optional['outputs.FlowAggregationConfig']:
        return pulumi.get(self, "aggregation_config")

    @property
    @pulumi.getter(name="fileType")
    def file_type(self) -> Optional['FlowFileType']:
        return pulumi.get(self, "file_type")

    @property
    @pulumi.getter(name="prefixConfig")
    def prefix_config(self) -> Optional['outputs.FlowPrefixConfig']:
        return pulumi.get(self, "prefix_config")


@pulumi.output_type
class FlowS3SourceProperties(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bucketName":
            suggest = "bucket_name"
        elif key == "bucketPrefix":
            suggest = "bucket_prefix"

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

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

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

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

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

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


@pulumi.output_type
class FlowSalesforceDestinationProperties(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "errorHandlingConfig":
            suggest = "error_handling_config"
        elif key == "idFieldNames":
            suggest = "id_field_names"
        elif key == "writeOperationType":
            suggest = "write_operation_type"

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

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

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

    def __init__(__self__, *,
                 object: str,
                 error_handling_config: Optional['outputs.FlowErrorHandlingConfig'] = None,
                 id_field_names: Optional[Sequence[str]] = None,
                 write_operation_type: Optional['FlowWriteOperationType'] = None):
        """
        :param Sequence[str] id_field_names: List of fields used as ID when performing a write operation.
        """
        pulumi.set(__self__, "object", object)
        if error_handling_config is not None:
            pulumi.set(__self__, "error_handling_config", error_handling_config)
        if id_field_names is not None:
            pulumi.set(__self__, "id_field_names", id_field_names)
        if write_operation_type is not None:
            pulumi.set(__self__, "write_operation_type", write_operation_type)

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

    @property
    @pulumi.getter(name="errorHandlingConfig")
    def error_handling_config(self) -> Optional['outputs.FlowErrorHandlingConfig']:
        return pulumi.get(self, "error_handling_config")

    @property
    @pulumi.getter(name="idFieldNames")
    def id_field_names(self) -> Optional[Sequence[str]]:
        """
        List of fields used as ID when performing a write operation.
        """
        return pulumi.get(self, "id_field_names")

    @property
    @pulumi.getter(name="writeOperationType")
    def write_operation_type(self) -> Optional['FlowWriteOperationType']:
        return pulumi.get(self, "write_operation_type")


@pulumi.output_type
class FlowSalesforceSourceProperties(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "enableDynamicFieldUpdate":
            suggest = "enable_dynamic_field_update"
        elif key == "includeDeletedRecords":
            suggest = "include_deleted_records"

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

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

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

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

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

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

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


@pulumi.output_type
class FlowScheduledTriggerProperties(dict):
    """
    Details required for scheduled trigger type
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "scheduleExpression":
            suggest = "schedule_expression"
        elif key == "dataPullMode":
            suggest = "data_pull_mode"
        elif key == "scheduleEndTime":
            suggest = "schedule_end_time"
        elif key == "scheduleOffset":
            suggest = "schedule_offset"
        elif key == "scheduleStartTime":
            suggest = "schedule_start_time"
        elif key == "timeZone":
            suggest = "time_zone"

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

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

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

    def __init__(__self__, *,
                 schedule_expression: str,
                 data_pull_mode: Optional['FlowScheduledTriggerPropertiesDataPullMode'] = None,
                 schedule_end_time: Optional[float] = None,
                 schedule_offset: Optional[float] = None,
                 schedule_start_time: Optional[float] = None,
                 time_zone: Optional[str] = None):
        """
        Details required for scheduled trigger type
        """
        pulumi.set(__self__, "schedule_expression", schedule_expression)
        if data_pull_mode is not None:
            pulumi.set(__self__, "data_pull_mode", data_pull_mode)
        if schedule_end_time is not None:
            pulumi.set(__self__, "schedule_end_time", schedule_end_time)
        if schedule_offset is not None:
            pulumi.set(__self__, "schedule_offset", schedule_offset)
        if schedule_start_time is not None:
            pulumi.set(__self__, "schedule_start_time", schedule_start_time)
        if time_zone is not None:
            pulumi.set(__self__, "time_zone", time_zone)

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

    @property
    @pulumi.getter(name="dataPullMode")
    def data_pull_mode(self) -> Optional['FlowScheduledTriggerPropertiesDataPullMode']:
        return pulumi.get(self, "data_pull_mode")

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

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

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

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


@pulumi.output_type
class FlowServiceNowSourceProperties(dict):
    def __init__(__self__, *,
                 object: str):
        pulumi.set(__self__, "object", object)

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


@pulumi.output_type
class FlowSingularSourceProperties(dict):
    def __init__(__self__, *,
                 object: str):
        pulumi.set(__self__, "object", object)

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


@pulumi.output_type
class FlowSlackSourceProperties(dict):
    def __init__(__self__, *,
                 object: str):
        pulumi.set(__self__, "object", object)

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


@pulumi.output_type
class FlowSnowflakeDestinationProperties(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "intermediateBucketName":
            suggest = "intermediate_bucket_name"
        elif key == "bucketPrefix":
            suggest = "bucket_prefix"
        elif key == "errorHandlingConfig":
            suggest = "error_handling_config"

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

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

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

    def __init__(__self__, *,
                 intermediate_bucket_name: str,
                 object: str,
                 bucket_prefix: Optional[str] = None,
                 error_handling_config: Optional['outputs.FlowErrorHandlingConfig'] = None):
        pulumi.set(__self__, "intermediate_bucket_name", intermediate_bucket_name)
        pulumi.set(__self__, "object", object)
        if bucket_prefix is not None:
            pulumi.set(__self__, "bucket_prefix", bucket_prefix)
        if error_handling_config is not None:
            pulumi.set(__self__, "error_handling_config", error_handling_config)

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

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

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

    @property
    @pulumi.getter(name="errorHandlingConfig")
    def error_handling_config(self) -> Optional['outputs.FlowErrorHandlingConfig']:
        return pulumi.get(self, "error_handling_config")


@pulumi.output_type
class FlowSourceConnectorProperties(dict):
    """
    Source connector details required to query a connector
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "googleAnalytics":
            suggest = "google_analytics"
        elif key == "inforNexus":
            suggest = "infor_nexus"
        elif key == "serviceNow":
            suggest = "service_now"

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

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

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

    def __init__(__self__, *,
                 amplitude: Optional['outputs.FlowAmplitudeSourceProperties'] = None,
                 datadog: Optional['outputs.FlowDatadogSourceProperties'] = None,
                 dynatrace: Optional['outputs.FlowDynatraceSourceProperties'] = None,
                 google_analytics: Optional['outputs.FlowGoogleAnalyticsSourceProperties'] = None,
                 infor_nexus: Optional['outputs.FlowInforNexusSourceProperties'] = None,
                 marketo: Optional['outputs.FlowMarketoSourceProperties'] = None,
                 s3: Optional['outputs.FlowS3SourceProperties'] = None,
                 salesforce: Optional['outputs.FlowSalesforceSourceProperties'] = None,
                 service_now: Optional['outputs.FlowServiceNowSourceProperties'] = None,
                 singular: Optional['outputs.FlowSingularSourceProperties'] = None,
                 slack: Optional['outputs.FlowSlackSourceProperties'] = None,
                 trendmicro: Optional['outputs.FlowTrendmicroSourceProperties'] = None,
                 veeva: Optional['outputs.FlowVeevaSourceProperties'] = None,
                 zendesk: Optional['outputs.FlowZendeskSourceProperties'] = None):
        """
        Source connector details required to query a connector
        """
        if amplitude is not None:
            pulumi.set(__self__, "amplitude", amplitude)
        if datadog is not None:
            pulumi.set(__self__, "datadog", datadog)
        if dynatrace is not None:
            pulumi.set(__self__, "dynatrace", dynatrace)
        if google_analytics is not None:
            pulumi.set(__self__, "google_analytics", google_analytics)
        if infor_nexus is not None:
            pulumi.set(__self__, "infor_nexus", infor_nexus)
        if marketo is not None:
            pulumi.set(__self__, "marketo", marketo)
        if s3 is not None:
            pulumi.set(__self__, "s3", s3)
        if salesforce is not None:
            pulumi.set(__self__, "salesforce", salesforce)
        if service_now is not None:
            pulumi.set(__self__, "service_now", service_now)
        if singular is not None:
            pulumi.set(__self__, "singular", singular)
        if slack is not None:
            pulumi.set(__self__, "slack", slack)
        if trendmicro is not None:
            pulumi.set(__self__, "trendmicro", trendmicro)
        if veeva is not None:
            pulumi.set(__self__, "veeva", veeva)
        if zendesk is not None:
            pulumi.set(__self__, "zendesk", zendesk)

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

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

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

    @property
    @pulumi.getter(name="googleAnalytics")
    def google_analytics(self) -> Optional['outputs.FlowGoogleAnalyticsSourceProperties']:
        return pulumi.get(self, "google_analytics")

    @property
    @pulumi.getter(name="inforNexus")
    def infor_nexus(self) -> Optional['outputs.FlowInforNexusSourceProperties']:
        return pulumi.get(self, "infor_nexus")

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

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

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

    @property
    @pulumi.getter(name="serviceNow")
    def service_now(self) -> Optional['outputs.FlowServiceNowSourceProperties']:
        return pulumi.get(self, "service_now")

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

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

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

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

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


@pulumi.output_type
class FlowSourceFlowConfig(dict):
    """
    Configurations of Source connector of the flow.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "connectorType":
            suggest = "connector_type"
        elif key == "sourceConnectorProperties":
            suggest = "source_connector_properties"
        elif key == "connectorProfileName":
            suggest = "connector_profile_name"
        elif key == "incrementalPullConfig":
            suggest = "incremental_pull_config"

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

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

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

    def __init__(__self__, *,
                 connector_type: 'FlowConnectorType',
                 source_connector_properties: 'outputs.FlowSourceConnectorProperties',
                 connector_profile_name: Optional[str] = None,
                 incremental_pull_config: Optional['outputs.FlowIncrementalPullConfig'] = None):
        """
        Configurations of Source connector of the flow.
        :param 'FlowConnectorType' connector_type: Type of source connector
        :param 'FlowSourceConnectorProperties' source_connector_properties: Source connector details required to query a connector
        :param str connector_profile_name: Name of source connector profile
        :param 'FlowIncrementalPullConfig' incremental_pull_config: Configuration for scheduled incremental data pull
        """
        pulumi.set(__self__, "connector_type", connector_type)
        pulumi.set(__self__, "source_connector_properties", source_connector_properties)
        if connector_profile_name is not None:
            pulumi.set(__self__, "connector_profile_name", connector_profile_name)
        if incremental_pull_config is not None:
            pulumi.set(__self__, "incremental_pull_config", incremental_pull_config)

    @property
    @pulumi.getter(name="connectorType")
    def connector_type(self) -> 'FlowConnectorType':
        """
        Type of source connector
        """
        return pulumi.get(self, "connector_type")

    @property
    @pulumi.getter(name="sourceConnectorProperties")
    def source_connector_properties(self) -> 'outputs.FlowSourceConnectorProperties':
        """
        Source connector details required to query a connector
        """
        return pulumi.get(self, "source_connector_properties")

    @property
    @pulumi.getter(name="connectorProfileName")
    def connector_profile_name(self) -> Optional[str]:
        """
        Name of source connector profile
        """
        return pulumi.get(self, "connector_profile_name")

    @property
    @pulumi.getter(name="incrementalPullConfig")
    def incremental_pull_config(self) -> Optional['outputs.FlowIncrementalPullConfig']:
        """
        Configuration for scheduled incremental data pull
        """
        return pulumi.get(self, "incremental_pull_config")


@pulumi.output_type
class FlowTag(dict):
    """
    A label for tagging AppFlow resources
    """
    def __init__(__self__, *,
                 key: str,
                 value: str):
        """
        A label for tagging AppFlow resources
        :param str key: A string used to identify this tag
        :param str value: A string containing the value for the tag
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        A string used to identify this tag
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        A string containing the value for the tag
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class FlowTask(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "sourceFields":
            suggest = "source_fields"
        elif key == "taskType":
            suggest = "task_type"
        elif key == "connectorOperator":
            suggest = "connector_operator"
        elif key == "destinationField":
            suggest = "destination_field"
        elif key == "taskProperties":
            suggest = "task_properties"

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

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

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

    def __init__(__self__, *,
                 source_fields: Sequence[str],
                 task_type: 'FlowTaskType',
                 connector_operator: Optional['outputs.FlowConnectorOperator'] = None,
                 destination_field: Optional[str] = None,
                 task_properties: Optional[Sequence['outputs.FlowTaskPropertiesObject']] = None):
        """
        :param Sequence[str] source_fields: Source fields on which particular task will be applied
        :param 'FlowTaskType' task_type: Type of task
        :param 'FlowConnectorOperator' connector_operator: Operation to be performed on provided source fields
        :param str destination_field: A field value on which source field should be validated
        :param Sequence['FlowTaskPropertiesObject'] task_properties: A Map used to store task related info
        """
        pulumi.set(__self__, "source_fields", source_fields)
        pulumi.set(__self__, "task_type", task_type)
        if connector_operator is not None:
            pulumi.set(__self__, "connector_operator", connector_operator)
        if destination_field is not None:
            pulumi.set(__self__, "destination_field", destination_field)
        if task_properties is not None:
            pulumi.set(__self__, "task_properties", task_properties)

    @property
    @pulumi.getter(name="sourceFields")
    def source_fields(self) -> Sequence[str]:
        """
        Source fields on which particular task will be applied
        """
        return pulumi.get(self, "source_fields")

    @property
    @pulumi.getter(name="taskType")
    def task_type(self) -> 'FlowTaskType':
        """
        Type of task
        """
        return pulumi.get(self, "task_type")

    @property
    @pulumi.getter(name="connectorOperator")
    def connector_operator(self) -> Optional['outputs.FlowConnectorOperator']:
        """
        Operation to be performed on provided source fields
        """
        return pulumi.get(self, "connector_operator")

    @property
    @pulumi.getter(name="destinationField")
    def destination_field(self) -> Optional[str]:
        """
        A field value on which source field should be validated
        """
        return pulumi.get(self, "destination_field")

    @property
    @pulumi.getter(name="taskProperties")
    def task_properties(self) -> Optional[Sequence['outputs.FlowTaskPropertiesObject']]:
        """
        A Map used to store task related info
        """
        return pulumi.get(self, "task_properties")


@pulumi.output_type
class FlowTaskPropertiesObject(dict):
    """
    An object used to store task related info
    """
    def __init__(__self__, *,
                 key: 'FlowOperatorPropertiesKeys',
                 value: str):
        """
        An object used to store task related info
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

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


@pulumi.output_type
class FlowTrendmicroSourceProperties(dict):
    def __init__(__self__, *,
                 object: str):
        pulumi.set(__self__, "object", object)

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


@pulumi.output_type
class FlowTriggerConfig(dict):
    """
    Trigger settings of the flow.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "triggerType":
            suggest = "trigger_type"
        elif key == "triggerProperties":
            suggest = "trigger_properties"

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

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

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

    def __init__(__self__, *,
                 trigger_type: 'FlowTriggerType',
                 trigger_properties: Optional['outputs.FlowScheduledTriggerProperties'] = None):
        """
        Trigger settings of the flow.
        :param 'FlowTriggerType' trigger_type: Trigger type of the flow
        :param 'FlowScheduledTriggerProperties' trigger_properties: Details required based on the type of trigger
        """
        pulumi.set(__self__, "trigger_type", trigger_type)
        if trigger_properties is not None:
            pulumi.set(__self__, "trigger_properties", trigger_properties)

    @property
    @pulumi.getter(name="triggerType")
    def trigger_type(self) -> 'FlowTriggerType':
        """
        Trigger type of the flow
        """
        return pulumi.get(self, "trigger_type")

    @property
    @pulumi.getter(name="triggerProperties")
    def trigger_properties(self) -> Optional['outputs.FlowScheduledTriggerProperties']:
        """
        Details required based on the type of trigger
        """
        return pulumi.get(self, "trigger_properties")


@pulumi.output_type
class FlowUpsolverDestinationProperties(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bucketName":
            suggest = "bucket_name"
        elif key == "s3OutputFormatConfig":
            suggest = "s3_output_format_config"
        elif key == "bucketPrefix":
            suggest = "bucket_prefix"

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

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

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

    def __init__(__self__, *,
                 bucket_name: str,
                 s3_output_format_config: 'outputs.FlowUpsolverS3OutputFormatConfig',
                 bucket_prefix: Optional[str] = None):
        pulumi.set(__self__, "bucket_name", bucket_name)
        pulumi.set(__self__, "s3_output_format_config", s3_output_format_config)
        if bucket_prefix is not None:
            pulumi.set(__self__, "bucket_prefix", bucket_prefix)

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

    @property
    @pulumi.getter(name="s3OutputFormatConfig")
    def s3_output_format_config(self) -> 'outputs.FlowUpsolverS3OutputFormatConfig':
        return pulumi.get(self, "s3_output_format_config")

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


@pulumi.output_type
class FlowUpsolverS3OutputFormatConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "prefixConfig":
            suggest = "prefix_config"
        elif key == "aggregationConfig":
            suggest = "aggregation_config"
        elif key == "fileType":
            suggest = "file_type"

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

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

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

    def __init__(__self__, *,
                 prefix_config: 'outputs.FlowPrefixConfig',
                 aggregation_config: Optional['outputs.FlowAggregationConfig'] = None,
                 file_type: Optional['FlowFileType'] = None):
        pulumi.set(__self__, "prefix_config", prefix_config)
        if aggregation_config is not None:
            pulumi.set(__self__, "aggregation_config", aggregation_config)
        if file_type is not None:
            pulumi.set(__self__, "file_type", file_type)

    @property
    @pulumi.getter(name="prefixConfig")
    def prefix_config(self) -> 'outputs.FlowPrefixConfig':
        return pulumi.get(self, "prefix_config")

    @property
    @pulumi.getter(name="aggregationConfig")
    def aggregation_config(self) -> Optional['outputs.FlowAggregationConfig']:
        return pulumi.get(self, "aggregation_config")

    @property
    @pulumi.getter(name="fileType")
    def file_type(self) -> Optional['FlowFileType']:
        return pulumi.get(self, "file_type")


@pulumi.output_type
class FlowVeevaSourceProperties(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "documentType":
            suggest = "document_type"
        elif key == "includeAllVersions":
            suggest = "include_all_versions"
        elif key == "includeRenditions":
            suggest = "include_renditions"
        elif key == "includeSourceFiles":
            suggest = "include_source_files"

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

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

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

    def __init__(__self__, *,
                 object: str,
                 document_type: Optional[str] = None,
                 include_all_versions: Optional[bool] = None,
                 include_renditions: Optional[bool] = None,
                 include_source_files: Optional[bool] = None):
        pulumi.set(__self__, "object", object)
        if document_type is not None:
            pulumi.set(__self__, "document_type", document_type)
        if include_all_versions is not None:
            pulumi.set(__self__, "include_all_versions", include_all_versions)
        if include_renditions is not None:
            pulumi.set(__self__, "include_renditions", include_renditions)
        if include_source_files is not None:
            pulumi.set(__self__, "include_source_files", include_source_files)

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

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

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

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

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


@pulumi.output_type
class FlowZendeskDestinationProperties(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "errorHandlingConfig":
            suggest = "error_handling_config"
        elif key == "idFieldNames":
            suggest = "id_field_names"
        elif key == "writeOperationType":
            suggest = "write_operation_type"

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

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

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

    def __init__(__self__, *,
                 object: str,
                 error_handling_config: Optional['outputs.FlowErrorHandlingConfig'] = None,
                 id_field_names: Optional[Sequence[str]] = None,
                 write_operation_type: Optional['FlowWriteOperationType'] = None):
        """
        :param Sequence[str] id_field_names: List of fields used as ID when performing a write operation.
        """
        pulumi.set(__self__, "object", object)
        if error_handling_config is not None:
            pulumi.set(__self__, "error_handling_config", error_handling_config)
        if id_field_names is not None:
            pulumi.set(__self__, "id_field_names", id_field_names)
        if write_operation_type is not None:
            pulumi.set(__self__, "write_operation_type", write_operation_type)

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

    @property
    @pulumi.getter(name="errorHandlingConfig")
    def error_handling_config(self) -> Optional['outputs.FlowErrorHandlingConfig']:
        return pulumi.get(self, "error_handling_config")

    @property
    @pulumi.getter(name="idFieldNames")
    def id_field_names(self) -> Optional[Sequence[str]]:
        """
        List of fields used as ID when performing a write operation.
        """
        return pulumi.get(self, "id_field_names")

    @property
    @pulumi.getter(name="writeOperationType")
    def write_operation_type(self) -> Optional['FlowWriteOperationType']:
        return pulumi.get(self, "write_operation_type")


@pulumi.output_type
class FlowZendeskSourceProperties(dict):
    def __init__(__self__, *,
                 object: str):
        pulumi.set(__self__, "object", object)

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


