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

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

__all__ = [
    'ConnectorProfileAmplitudeConnectorProfileCredentialsArgs',
    'ConnectorProfileConnectorOAuthRequestArgs',
    'ConnectorProfileConnectorProfileConfigArgs',
    'ConnectorProfileConnectorProfileCredentialsArgs',
    'ConnectorProfileConnectorProfilePropertiesArgs',
    'ConnectorProfileDatadogConnectorProfileCredentialsArgs',
    'ConnectorProfileDatadogConnectorProfilePropertiesArgs',
    'ConnectorProfileDynatraceConnectorProfileCredentialsArgs',
    'ConnectorProfileDynatraceConnectorProfilePropertiesArgs',
    'ConnectorProfileGoogleAnalyticsConnectorProfileCredentialsArgs',
    'ConnectorProfileInforNexusConnectorProfileCredentialsArgs',
    'ConnectorProfileInforNexusConnectorProfilePropertiesArgs',
    'ConnectorProfileMarketoConnectorProfileCredentialsArgs',
    'ConnectorProfileMarketoConnectorProfilePropertiesArgs',
    'ConnectorProfileRedshiftConnectorProfileCredentialsArgs',
    'ConnectorProfileRedshiftConnectorProfilePropertiesArgs',
    'ConnectorProfileSalesforceConnectorProfileCredentialsArgs',
    'ConnectorProfileSalesforceConnectorProfilePropertiesArgs',
    'ConnectorProfileServiceNowConnectorProfileCredentialsArgs',
    'ConnectorProfileServiceNowConnectorProfilePropertiesArgs',
    'ConnectorProfileSingularConnectorProfileCredentialsArgs',
    'ConnectorProfileSlackConnectorProfileCredentialsArgs',
    'ConnectorProfileSlackConnectorProfilePropertiesArgs',
    'ConnectorProfileSnowflakeConnectorProfileCredentialsArgs',
    'ConnectorProfileSnowflakeConnectorProfilePropertiesArgs',
    'ConnectorProfileTrendmicroConnectorProfileCredentialsArgs',
    'ConnectorProfileVeevaConnectorProfileCredentialsArgs',
    'ConnectorProfileVeevaConnectorProfilePropertiesArgs',
    'ConnectorProfileZendeskConnectorProfileCredentialsArgs',
    'ConnectorProfileZendeskConnectorProfilePropertiesArgs',
    'FlowAggregationConfigArgs',
    'FlowAmplitudeSourcePropertiesArgs',
    'FlowConnectorOperatorArgs',
    'FlowDatadogSourcePropertiesArgs',
    'FlowDestinationConnectorPropertiesArgs',
    'FlowDestinationFlowConfigArgs',
    'FlowDynatraceSourcePropertiesArgs',
    'FlowErrorHandlingConfigArgs',
    'FlowEventBridgeDestinationPropertiesArgs',
    'FlowGoogleAnalyticsSourcePropertiesArgs',
    'FlowIncrementalPullConfigArgs',
    'FlowInforNexusSourcePropertiesArgs',
    'FlowLookoutMetricsDestinationPropertiesArgs',
    'FlowMarketoSourcePropertiesArgs',
    'FlowPrefixConfigArgs',
    'FlowRedshiftDestinationPropertiesArgs',
    'FlowS3DestinationPropertiesArgs',
    'FlowS3OutputFormatConfigArgs',
    'FlowS3SourcePropertiesArgs',
    'FlowSalesforceDestinationPropertiesArgs',
    'FlowSalesforceSourcePropertiesArgs',
    'FlowScheduledTriggerPropertiesArgs',
    'FlowServiceNowSourcePropertiesArgs',
    'FlowSingularSourcePropertiesArgs',
    'FlowSlackSourcePropertiesArgs',
    'FlowSnowflakeDestinationPropertiesArgs',
    'FlowSourceConnectorPropertiesArgs',
    'FlowSourceFlowConfigArgs',
    'FlowTagArgs',
    'FlowTaskPropertiesObjectArgs',
    'FlowTaskArgs',
    'FlowTrendmicroSourcePropertiesArgs',
    'FlowTriggerConfigArgs',
    'FlowUpsolverDestinationPropertiesArgs',
    'FlowUpsolverS3OutputFormatConfigArgs',
    'FlowVeevaSourcePropertiesArgs',
    'FlowZendeskDestinationPropertiesArgs',
    'FlowZendeskSourcePropertiesArgs',
]

@pulumi.input_type
class ConnectorProfileAmplitudeConnectorProfileCredentialsArgs:
    def __init__(__self__, *,
                 api_key: pulumi.Input[str],
                 secret_key: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        A unique alphanumeric identiﬁer used to authenticate a user, developer, or calling program to your API.
        """
        return pulumi.get(self, "api_key")

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

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

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


@pulumi.input_type
class ConnectorProfileConnectorOAuthRequestArgs:
    def __init__(__self__, *,
                 auth_code: Optional[pulumi.Input[str]] = None,
                 redirect_uri: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] auth_code: The code provided by the connector when it has been authenticated via the connected app.
        :param pulumi.Input[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[pulumi.Input[str]]:
        """
        The code provided by the connector when it has been authenticated via the connected app.
        """
        return pulumi.get(self, "auth_code")

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

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

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


@pulumi.input_type
class ConnectorProfileConnectorProfileConfigArgs:
    def __init__(__self__, *,
                 connector_profile_credentials: pulumi.Input['ConnectorProfileConnectorProfileCredentialsArgs'],
                 connector_profile_properties: Optional[pulumi.Input['ConnectorProfileConnectorProfilePropertiesArgs']] = 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) -> pulumi.Input['ConnectorProfileConnectorProfileCredentialsArgs']:
        return pulumi.get(self, "connector_profile_credentials")

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

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

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


@pulumi.input_type
class ConnectorProfileConnectorProfileCredentialsArgs:
    def __init__(__self__, *,
                 amplitude: Optional[pulumi.Input['ConnectorProfileAmplitudeConnectorProfileCredentialsArgs']] = None,
                 datadog: Optional[pulumi.Input['ConnectorProfileDatadogConnectorProfileCredentialsArgs']] = None,
                 dynatrace: Optional[pulumi.Input['ConnectorProfileDynatraceConnectorProfileCredentialsArgs']] = None,
                 google_analytics: Optional[pulumi.Input['ConnectorProfileGoogleAnalyticsConnectorProfileCredentialsArgs']] = None,
                 infor_nexus: Optional[pulumi.Input['ConnectorProfileInforNexusConnectorProfileCredentialsArgs']] = None,
                 marketo: Optional[pulumi.Input['ConnectorProfileMarketoConnectorProfileCredentialsArgs']] = None,
                 redshift: Optional[pulumi.Input['ConnectorProfileRedshiftConnectorProfileCredentialsArgs']] = None,
                 salesforce: Optional[pulumi.Input['ConnectorProfileSalesforceConnectorProfileCredentialsArgs']] = None,
                 service_now: Optional[pulumi.Input['ConnectorProfileServiceNowConnectorProfileCredentialsArgs']] = None,
                 singular: Optional[pulumi.Input['ConnectorProfileSingularConnectorProfileCredentialsArgs']] = None,
                 slack: Optional[pulumi.Input['ConnectorProfileSlackConnectorProfileCredentialsArgs']] = None,
                 snowflake: Optional[pulumi.Input['ConnectorProfileSnowflakeConnectorProfileCredentialsArgs']] = None,
                 trendmicro: Optional[pulumi.Input['ConnectorProfileTrendmicroConnectorProfileCredentialsArgs']] = None,
                 veeva: Optional[pulumi.Input['ConnectorProfileVeevaConnectorProfileCredentialsArgs']] = None,
                 zendesk: Optional[pulumi.Input['ConnectorProfileZendeskConnectorProfileCredentialsArgs']] = 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[pulumi.Input['ConnectorProfileAmplitudeConnectorProfileCredentialsArgs']]:
        return pulumi.get(self, "amplitude")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class ConnectorProfileConnectorProfilePropertiesArgs:
    def __init__(__self__, *,
                 datadog: Optional[pulumi.Input['ConnectorProfileDatadogConnectorProfilePropertiesArgs']] = None,
                 dynatrace: Optional[pulumi.Input['ConnectorProfileDynatraceConnectorProfilePropertiesArgs']] = None,
                 infor_nexus: Optional[pulumi.Input['ConnectorProfileInforNexusConnectorProfilePropertiesArgs']] = None,
                 marketo: Optional[pulumi.Input['ConnectorProfileMarketoConnectorProfilePropertiesArgs']] = None,
                 redshift: Optional[pulumi.Input['ConnectorProfileRedshiftConnectorProfilePropertiesArgs']] = None,
                 salesforce: Optional[pulumi.Input['ConnectorProfileSalesforceConnectorProfilePropertiesArgs']] = None,
                 service_now: Optional[pulumi.Input['ConnectorProfileServiceNowConnectorProfilePropertiesArgs']] = None,
                 slack: Optional[pulumi.Input['ConnectorProfileSlackConnectorProfilePropertiesArgs']] = None,
                 snowflake: Optional[pulumi.Input['ConnectorProfileSnowflakeConnectorProfilePropertiesArgs']] = None,
                 veeva: Optional[pulumi.Input['ConnectorProfileVeevaConnectorProfilePropertiesArgs']] = None,
                 zendesk: Optional[pulumi.Input['ConnectorProfileZendeskConnectorProfilePropertiesArgs']] = 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[pulumi.Input['ConnectorProfileDatadogConnectorProfilePropertiesArgs']]:
        return pulumi.get(self, "datadog")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class ConnectorProfileDatadogConnectorProfileCredentialsArgs:
    def __init__(__self__, *,
                 api_key: pulumi.Input[str],
                 application_key: pulumi.Input[str]):
        """
        :param pulumi.Input[str] api_key: A unique alphanumeric identiﬁer used to authenticate a user, developer, or calling program to your API.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        A unique alphanumeric identiﬁer used to authenticate a user, developer, or calling program to your API.
        """
        return pulumi.get(self, "api_key")

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

    @property
    @pulumi.getter(name="applicationKey")
    def application_key(self) -> pulumi.Input[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")

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


@pulumi.input_type
class ConnectorProfileDatadogConnectorProfilePropertiesArgs:
    def __init__(__self__, *,
                 instance_url: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The location of the Datadog resource
        """
        return pulumi.get(self, "instance_url")

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


@pulumi.input_type
class ConnectorProfileDynatraceConnectorProfileCredentialsArgs:
    def __init__(__self__, *,
                 api_token: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The API tokens used by Dynatrace API to authenticate various API calls.
        """
        return pulumi.get(self, "api_token")

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


@pulumi.input_type
class ConnectorProfileDynatraceConnectorProfilePropertiesArgs:
    def __init__(__self__, *,
                 instance_url: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The location of the Dynatrace resource
        """
        return pulumi.get(self, "instance_url")

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


@pulumi.input_type
class ConnectorProfileGoogleAnalyticsConnectorProfileCredentialsArgs:
    def __init__(__self__, *,
                 client_id: pulumi.Input[str],
                 client_secret: pulumi.Input[str],
                 access_token: Optional[pulumi.Input[str]] = None,
                 connector_o_auth_request: Optional[pulumi.Input['ConnectorProfileConnectorOAuthRequestArgs']] = None,
                 refresh_token: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] client_id: The identiﬁer for the desired client.
        :param pulumi.Input[str] client_secret: The client secret used by the oauth client to authenticate to the authorization server.
        :param pulumi.Input[str] access_token: The credentials used to access protected resources.
        :param pulumi.Input['ConnectorProfileConnectorOAuthRequestArgs'] connector_o_auth_request: The oauth needed to request security tokens from the connector endpoint.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The identiﬁer for the desired client.
        """
        return pulumi.get(self, "client_id")

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class ConnectorProfileInforNexusConnectorProfileCredentialsArgs:
    def __init__(__self__, *,
                 access_key_id: pulumi.Input[str],
                 datakey: pulumi.Input[str],
                 secret_access_key: pulumi.Input[str],
                 user_id: pulumi.Input[str]):
        """
        :param pulumi.Input[str] access_key_id: The Access Key portion of the credentials.
        :param pulumi.Input[str] datakey: The encryption keys used to encrypt data.
        :param pulumi.Input[str] secret_access_key: The secret key used to sign requests.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The Access Key portion of the credentials.
        """
        return pulumi.get(self, "access_key_id")

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

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

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

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

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

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

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


@pulumi.input_type
class ConnectorProfileInforNexusConnectorProfilePropertiesArgs:
    def __init__(__self__, *,
                 instance_url: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The location of the InforNexus resource
        """
        return pulumi.get(self, "instance_url")

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


@pulumi.input_type
class ConnectorProfileMarketoConnectorProfileCredentialsArgs:
    def __init__(__self__, *,
                 client_id: pulumi.Input[str],
                 client_secret: pulumi.Input[str],
                 access_token: Optional[pulumi.Input[str]] = None,
                 connector_o_auth_request: Optional[pulumi.Input['ConnectorProfileConnectorOAuthRequestArgs']] = None):
        """
        :param pulumi.Input[str] client_id: The identiﬁer for the desired client.
        :param pulumi.Input[str] client_secret: The client secret used by the oauth client to authenticate to the authorization server.
        :param pulumi.Input[str] access_token: The credentials used to access protected resources.
        :param pulumi.Input['ConnectorProfileConnectorOAuthRequestArgs'] 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) -> pulumi.Input[str]:
        """
        The identiﬁer for the desired client.
        """
        return pulumi.get(self, "client_id")

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

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

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

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

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

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

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


@pulumi.input_type
class ConnectorProfileMarketoConnectorProfilePropertiesArgs:
    def __init__(__self__, *,
                 instance_url: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The location of the Marketo resource
        """
        return pulumi.get(self, "instance_url")

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


@pulumi.input_type
class ConnectorProfileRedshiftConnectorProfileCredentialsArgs:
    def __init__(__self__, *,
                 password: pulumi.Input[str],
                 username: pulumi.Input[str]):
        """
        :param pulumi.Input[str] password: The password that corresponds to the username.
        :param pulumi.Input[str] username: The name of the user.
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)

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

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

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

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


@pulumi.input_type
class ConnectorProfileRedshiftConnectorProfilePropertiesArgs:
    def __init__(__self__, *,
                 bucket_name: pulumi.Input[str],
                 database_url: pulumi.Input[str],
                 role_arn: pulumi.Input[str],
                 bucket_prefix: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] bucket_name: The name of the Amazon S3 bucket associated with Redshift.
        :param pulumi.Input[str] database_url: The JDBC URL of the Amazon Redshift cluster.
        :param pulumi.Input[str] role_arn: The Amazon Resource Name (ARN) of the IAM role.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The name of the Amazon S3 bucket associated with Redshift.
        """
        return pulumi.get(self, "bucket_name")

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

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

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

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

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

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

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


@pulumi.input_type
class ConnectorProfileSalesforceConnectorProfileCredentialsArgs:
    def __init__(__self__, *,
                 access_token: Optional[pulumi.Input[str]] = None,
                 client_credentials_arn: Optional[pulumi.Input[str]] = None,
                 connector_o_auth_request: Optional[pulumi.Input['ConnectorProfileConnectorOAuthRequestArgs']] = None,
                 refresh_token: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] access_token: The credentials used to access protected resources.
        :param pulumi.Input[str] client_credentials_arn: The client credentials to fetch access token and refresh token.
        :param pulumi.Input['ConnectorProfileConnectorOAuthRequestArgs'] connector_o_auth_request: The oauth needed to request security tokens from the connector endpoint.
        :param pulumi.Input[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[pulumi.Input[str]]:
        """
        The credentials used to access protected resources.
        """
        return pulumi.get(self, "access_token")

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

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

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

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

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

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

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


@pulumi.input_type
class ConnectorProfileSalesforceConnectorProfilePropertiesArgs:
    def __init__(__self__, *,
                 instance_url: Optional[pulumi.Input[str]] = None,
                 is_sandbox_environment: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[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[pulumi.Input[str]]:
        """
        The location of the Salesforce resource
        """
        return pulumi.get(self, "instance_url")

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

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

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


@pulumi.input_type
class ConnectorProfileServiceNowConnectorProfileCredentialsArgs:
    def __init__(__self__, *,
                 password: pulumi.Input[str],
                 username: pulumi.Input[str]):
        """
        :param pulumi.Input[str] password: The password that corresponds to the username.
        :param pulumi.Input[str] username: The name of the user.
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)

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

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

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

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


@pulumi.input_type
class ConnectorProfileServiceNowConnectorProfilePropertiesArgs:
    def __init__(__self__, *,
                 instance_url: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The location of the ServiceNow resource
        """
        return pulumi.get(self, "instance_url")

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


@pulumi.input_type
class ConnectorProfileSingularConnectorProfileCredentialsArgs:
    def __init__(__self__, *,
                 api_key: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        A unique alphanumeric identiﬁer used to authenticate a user, developer, or calling program to your API.
        """
        return pulumi.get(self, "api_key")

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


@pulumi.input_type
class ConnectorProfileSlackConnectorProfileCredentialsArgs:
    def __init__(__self__, *,
                 client_id: pulumi.Input[str],
                 client_secret: pulumi.Input[str],
                 access_token: Optional[pulumi.Input[str]] = None,
                 connector_o_auth_request: Optional[pulumi.Input['ConnectorProfileConnectorOAuthRequestArgs']] = None):
        """
        :param pulumi.Input[str] client_id: The identiﬁer for the desired client.
        :param pulumi.Input[str] client_secret: The client secret used by the oauth client to authenticate to the authorization server.
        :param pulumi.Input[str] access_token: The credentials used to access protected resources.
        :param pulumi.Input['ConnectorProfileConnectorOAuthRequestArgs'] 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) -> pulumi.Input[str]:
        """
        The identiﬁer for the desired client.
        """
        return pulumi.get(self, "client_id")

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

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

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

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

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

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

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


@pulumi.input_type
class ConnectorProfileSlackConnectorProfilePropertiesArgs:
    def __init__(__self__, *,
                 instance_url: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The location of the Slack resource
        """
        return pulumi.get(self, "instance_url")

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


@pulumi.input_type
class ConnectorProfileSnowflakeConnectorProfileCredentialsArgs:
    def __init__(__self__, *,
                 password: pulumi.Input[str],
                 username: pulumi.Input[str]):
        """
        :param pulumi.Input[str] password: The password that corresponds to the username.
        :param pulumi.Input[str] username: The name of the user.
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)

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

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

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

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


@pulumi.input_type
class ConnectorProfileSnowflakeConnectorProfilePropertiesArgs:
    def __init__(__self__, *,
                 bucket_name: pulumi.Input[str],
                 stage: pulumi.Input[str],
                 warehouse: pulumi.Input[str],
                 account_name: Optional[pulumi.Input[str]] = None,
                 bucket_prefix: Optional[pulumi.Input[str]] = None,
                 private_link_service_name: Optional[pulumi.Input[str]] = None,
                 region: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] bucket_name: The name of the Amazon S3 bucket associated with Snowﬂake.
        :param pulumi.Input[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 pulumi.Input[str] warehouse: The name of the Snowﬂake warehouse.
        :param pulumi.Input[str] account_name: The name of the account.
        :param pulumi.Input[str] bucket_prefix: The bucket prefix that refers to the Amazon S3 bucket associated with Snowﬂake.
        :param pulumi.Input[str] private_link_service_name: The Snowﬂake Private Link service name to be used for private data transfers.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The name of the Amazon S3 bucket associated with Snowﬂake.
        """
        return pulumi.get(self, "bucket_name")

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

    @property
    @pulumi.getter
    def stage(self) -> pulumi.Input[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")

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class ConnectorProfileTrendmicroConnectorProfileCredentialsArgs:
    def __init__(__self__, *,
                 api_secret_key: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The Secret Access Key portion of the credentials.
        """
        return pulumi.get(self, "api_secret_key")

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


@pulumi.input_type
class ConnectorProfileVeevaConnectorProfileCredentialsArgs:
    def __init__(__self__, *,
                 password: pulumi.Input[str],
                 username: pulumi.Input[str]):
        """
        :param pulumi.Input[str] password: The password that corresponds to the username.
        :param pulumi.Input[str] username: The name of the user.
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)

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

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

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

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


@pulumi.input_type
class ConnectorProfileVeevaConnectorProfilePropertiesArgs:
    def __init__(__self__, *,
                 instance_url: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The location of the Veeva resource
        """
        return pulumi.get(self, "instance_url")

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


@pulumi.input_type
class ConnectorProfileZendeskConnectorProfileCredentialsArgs:
    def __init__(__self__, *,
                 client_id: pulumi.Input[str],
                 client_secret: pulumi.Input[str],
                 access_token: Optional[pulumi.Input[str]] = None,
                 connector_o_auth_request: Optional[pulumi.Input['ConnectorProfileConnectorOAuthRequestArgs']] = None):
        """
        :param pulumi.Input[str] client_id: The identiﬁer for the desired client.
        :param pulumi.Input[str] client_secret: The client secret used by the oauth client to authenticate to the authorization server.
        :param pulumi.Input[str] access_token: The credentials used to access protected resources.
        :param pulumi.Input['ConnectorProfileConnectorOAuthRequestArgs'] 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) -> pulumi.Input[str]:
        """
        The identiﬁer for the desired client.
        """
        return pulumi.get(self, "client_id")

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

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

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

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

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

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

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


@pulumi.input_type
class ConnectorProfileZendeskConnectorProfilePropertiesArgs:
    def __init__(__self__, *,
                 instance_url: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The location of the Zendesk resource
        """
        return pulumi.get(self, "instance_url")

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


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

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


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

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

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


@pulumi.input_type
class FlowConnectorOperatorArgs:
    def __init__(__self__, *,
                 amplitude: Optional[pulumi.Input['FlowAmplitudeConnectorOperator']] = None,
                 datadog: Optional[pulumi.Input['FlowDatadogConnectorOperator']] = None,
                 dynatrace: Optional[pulumi.Input['FlowDynatraceConnectorOperator']] = None,
                 google_analytics: Optional[pulumi.Input['FlowGoogleAnalyticsConnectorOperator']] = None,
                 infor_nexus: Optional[pulumi.Input['FlowInforNexusConnectorOperator']] = None,
                 marketo: Optional[pulumi.Input['FlowMarketoConnectorOperator']] = None,
                 s3: Optional[pulumi.Input['FlowS3ConnectorOperator']] = None,
                 salesforce: Optional[pulumi.Input['FlowSalesforceConnectorOperator']] = None,
                 service_now: Optional[pulumi.Input['FlowServiceNowConnectorOperator']] = None,
                 singular: Optional[pulumi.Input['FlowSingularConnectorOperator']] = None,
                 slack: Optional[pulumi.Input['FlowSlackConnectorOperator']] = None,
                 trendmicro: Optional[pulumi.Input['FlowTrendmicroConnectorOperator']] = None,
                 veeva: Optional[pulumi.Input['FlowVeevaConnectorOperator']] = None,
                 zendesk: Optional[pulumi.Input['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[pulumi.Input['FlowAmplitudeConnectorOperator']]:
        return pulumi.get(self, "amplitude")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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


@pulumi.input_type
class FlowDestinationConnectorPropertiesArgs:
    def __init__(__self__, *,
                 event_bridge: Optional[pulumi.Input['FlowEventBridgeDestinationPropertiesArgs']] = None,
                 lookout_metrics: Optional[pulumi.Input['FlowLookoutMetricsDestinationPropertiesArgs']] = None,
                 redshift: Optional[pulumi.Input['FlowRedshiftDestinationPropertiesArgs']] = None,
                 s3: Optional[pulumi.Input['FlowS3DestinationPropertiesArgs']] = None,
                 salesforce: Optional[pulumi.Input['FlowSalesforceDestinationPropertiesArgs']] = None,
                 snowflake: Optional[pulumi.Input['FlowSnowflakeDestinationPropertiesArgs']] = None,
                 upsolver: Optional[pulumi.Input['FlowUpsolverDestinationPropertiesArgs']] = None,
                 zendesk: Optional[pulumi.Input['FlowZendeskDestinationPropertiesArgs']] = 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[pulumi.Input['FlowEventBridgeDestinationPropertiesArgs']]:
        return pulumi.get(self, "event_bridge")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class FlowDestinationFlowConfigArgs:
    def __init__(__self__, *,
                 connector_type: pulumi.Input['FlowConnectorType'],
                 destination_connector_properties: pulumi.Input['FlowDestinationConnectorPropertiesArgs'],
                 connector_profile_name: Optional[pulumi.Input[str]] = None):
        """
        Configurations of destination connector.
        :param pulumi.Input['FlowConnectorType'] connector_type: Destination connector type
        :param pulumi.Input['FlowDestinationConnectorPropertiesArgs'] destination_connector_properties: Destination connector details
        :param pulumi.Input[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) -> pulumi.Input['FlowConnectorType']:
        """
        Destination connector type
        """
        return pulumi.get(self, "connector_type")

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

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

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

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

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


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

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

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


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

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

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

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

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

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


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

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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


@pulumi.input_type
class FlowPrefixConfigArgs:
    def __init__(__self__, *,
                 prefix_format: Optional[pulumi.Input['FlowPrefixFormat']] = None,
                 prefix_type: Optional[pulumi.Input['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[pulumi.Input['FlowPrefixFormat']]:
        return pulumi.get(self, "prefix_format")

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

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

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


@pulumi.input_type
class FlowRedshiftDestinationPropertiesArgs:
    def __init__(__self__, *,
                 intermediate_bucket_name: pulumi.Input[str],
                 object: pulumi.Input[str],
                 bucket_prefix: Optional[pulumi.Input[str]] = None,
                 error_handling_config: Optional[pulumi.Input['FlowErrorHandlingConfigArgs']] = 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) -> pulumi.Input[str]:
        return pulumi.get(self, "intermediate_bucket_name")

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

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

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

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

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

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

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


@pulumi.input_type
class FlowS3DestinationPropertiesArgs:
    def __init__(__self__, *,
                 bucket_name: pulumi.Input[str],
                 bucket_prefix: Optional[pulumi.Input[str]] = None,
                 s3_output_format_config: Optional[pulumi.Input['FlowS3OutputFormatConfigArgs']] = 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) -> pulumi.Input[str]:
        return pulumi.get(self, "bucket_name")

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

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

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

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

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


@pulumi.input_type
class FlowS3OutputFormatConfigArgs:
    def __init__(__self__, *,
                 aggregation_config: Optional[pulumi.Input['FlowAggregationConfigArgs']] = None,
                 file_type: Optional[pulumi.Input['FlowFileType']] = None,
                 prefix_config: Optional[pulumi.Input['FlowPrefixConfigArgs']] = 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[pulumi.Input['FlowAggregationConfigArgs']]:
        return pulumi.get(self, "aggregation_config")

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

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

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

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

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


@pulumi.input_type
class FlowS3SourcePropertiesArgs:
    def __init__(__self__, *,
                 bucket_name: pulumi.Input[str],
                 bucket_prefix: pulumi.Input[str]):
        pulumi.set(__self__, "bucket_name", bucket_name)
        pulumi.set(__self__, "bucket_prefix", bucket_prefix)

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

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

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

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


@pulumi.input_type
class FlowSalesforceDestinationPropertiesArgs:
    def __init__(__self__, *,
                 object: pulumi.Input[str],
                 error_handling_config: Optional[pulumi.Input['FlowErrorHandlingConfigArgs']] = None,
                 id_field_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 write_operation_type: Optional[pulumi.Input['FlowWriteOperationType']] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[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) -> pulumi.Input[str]:
        return pulumi.get(self, "object")

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

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

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

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

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

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

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


@pulumi.input_type
class FlowSalesforceSourcePropertiesArgs:
    def __init__(__self__, *,
                 object: pulumi.Input[str],
                 enable_dynamic_field_update: Optional[pulumi.Input[bool]] = None,
                 include_deleted_records: Optional[pulumi.Input[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) -> pulumi.Input[str]:
        return pulumi.get(self, "object")

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

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

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

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

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


@pulumi.input_type
class FlowScheduledTriggerPropertiesArgs:
    def __init__(__self__, *,
                 schedule_expression: pulumi.Input[str],
                 data_pull_mode: Optional[pulumi.Input['FlowScheduledTriggerPropertiesDataPullMode']] = None,
                 schedule_end_time: Optional[pulumi.Input[float]] = None,
                 schedule_offset: Optional[pulumi.Input[float]] = None,
                 schedule_start_time: Optional[pulumi.Input[float]] = None,
                 time_zone: Optional[pulumi.Input[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) -> pulumi.Input[str]:
        return pulumi.get(self, "schedule_expression")

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

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

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

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

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

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

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

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

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

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

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


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

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

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


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

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

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


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

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

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


@pulumi.input_type
class FlowSnowflakeDestinationPropertiesArgs:
    def __init__(__self__, *,
                 intermediate_bucket_name: pulumi.Input[str],
                 object: pulumi.Input[str],
                 bucket_prefix: Optional[pulumi.Input[str]] = None,
                 error_handling_config: Optional[pulumi.Input['FlowErrorHandlingConfigArgs']] = 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) -> pulumi.Input[str]:
        return pulumi.get(self, "intermediate_bucket_name")

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

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

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

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

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

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

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


@pulumi.input_type
class FlowSourceConnectorPropertiesArgs:
    def __init__(__self__, *,
                 amplitude: Optional[pulumi.Input['FlowAmplitudeSourcePropertiesArgs']] = None,
                 datadog: Optional[pulumi.Input['FlowDatadogSourcePropertiesArgs']] = None,
                 dynatrace: Optional[pulumi.Input['FlowDynatraceSourcePropertiesArgs']] = None,
                 google_analytics: Optional[pulumi.Input['FlowGoogleAnalyticsSourcePropertiesArgs']] = None,
                 infor_nexus: Optional[pulumi.Input['FlowInforNexusSourcePropertiesArgs']] = None,
                 marketo: Optional[pulumi.Input['FlowMarketoSourcePropertiesArgs']] = None,
                 s3: Optional[pulumi.Input['FlowS3SourcePropertiesArgs']] = None,
                 salesforce: Optional[pulumi.Input['FlowSalesforceSourcePropertiesArgs']] = None,
                 service_now: Optional[pulumi.Input['FlowServiceNowSourcePropertiesArgs']] = None,
                 singular: Optional[pulumi.Input['FlowSingularSourcePropertiesArgs']] = None,
                 slack: Optional[pulumi.Input['FlowSlackSourcePropertiesArgs']] = None,
                 trendmicro: Optional[pulumi.Input['FlowTrendmicroSourcePropertiesArgs']] = None,
                 veeva: Optional[pulumi.Input['FlowVeevaSourcePropertiesArgs']] = None,
                 zendesk: Optional[pulumi.Input['FlowZendeskSourcePropertiesArgs']] = 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[pulumi.Input['FlowAmplitudeSourcePropertiesArgs']]:
        return pulumi.get(self, "amplitude")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class FlowSourceFlowConfigArgs:
    def __init__(__self__, *,
                 connector_type: pulumi.Input['FlowConnectorType'],
                 source_connector_properties: pulumi.Input['FlowSourceConnectorPropertiesArgs'],
                 connector_profile_name: Optional[pulumi.Input[str]] = None,
                 incremental_pull_config: Optional[pulumi.Input['FlowIncrementalPullConfigArgs']] = None):
        """
        Configurations of Source connector of the flow.
        :param pulumi.Input['FlowConnectorType'] connector_type: Type of source connector
        :param pulumi.Input['FlowSourceConnectorPropertiesArgs'] source_connector_properties: Source connector details required to query a connector
        :param pulumi.Input[str] connector_profile_name: Name of source connector profile
        :param pulumi.Input['FlowIncrementalPullConfigArgs'] 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) -> pulumi.Input['FlowConnectorType']:
        """
        Type of source connector
        """
        return pulumi.get(self, "connector_type")

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

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

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

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

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

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

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


@pulumi.input_type
class FlowTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        A label for tagging AppFlow resources
        :param pulumi.Input[str] key: A string used to identify this tag
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        A string used to identify this tag
        """
        return pulumi.get(self, "key")

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

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

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


@pulumi.input_type
class FlowTaskPropertiesObjectArgs:
    def __init__(__self__, *,
                 key: pulumi.Input['FlowOperatorPropertiesKeys'],
                 value: pulumi.Input[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) -> pulumi.Input['FlowOperatorPropertiesKeys']:
        return pulumi.get(self, "key")

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

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

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


@pulumi.input_type
class FlowTaskArgs:
    def __init__(__self__, *,
                 source_fields: pulumi.Input[Sequence[pulumi.Input[str]]],
                 task_type: pulumi.Input['FlowTaskType'],
                 connector_operator: Optional[pulumi.Input['FlowConnectorOperatorArgs']] = None,
                 destination_field: Optional[pulumi.Input[str]] = None,
                 task_properties: Optional[pulumi.Input[Sequence[pulumi.Input['FlowTaskPropertiesObjectArgs']]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] source_fields: Source fields on which particular task will be applied
        :param pulumi.Input['FlowTaskType'] task_type: Type of task
        :param pulumi.Input['FlowConnectorOperatorArgs'] connector_operator: Operation to be performed on provided source fields
        :param pulumi.Input[str] destination_field: A field value on which source field should be validated
        :param pulumi.Input[Sequence[pulumi.Input['FlowTaskPropertiesObjectArgs']]] 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) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        Source fields on which particular task will be applied
        """
        return pulumi.get(self, "source_fields")

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

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

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

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

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

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

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

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

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


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

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

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


@pulumi.input_type
class FlowTriggerConfigArgs:
    def __init__(__self__, *,
                 trigger_type: pulumi.Input['FlowTriggerType'],
                 trigger_properties: Optional[pulumi.Input['FlowScheduledTriggerPropertiesArgs']] = None):
        """
        Trigger settings of the flow.
        :param pulumi.Input['FlowTriggerType'] trigger_type: Trigger type of the flow
        :param pulumi.Input['FlowScheduledTriggerPropertiesArgs'] 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) -> pulumi.Input['FlowTriggerType']:
        """
        Trigger type of the flow
        """
        return pulumi.get(self, "trigger_type")

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

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

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


@pulumi.input_type
class FlowUpsolverDestinationPropertiesArgs:
    def __init__(__self__, *,
                 bucket_name: pulumi.Input[str],
                 s3_output_format_config: pulumi.Input['FlowUpsolverS3OutputFormatConfigArgs'],
                 bucket_prefix: Optional[pulumi.Input[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) -> pulumi.Input[str]:
        return pulumi.get(self, "bucket_name")

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

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

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

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

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


@pulumi.input_type
class FlowUpsolverS3OutputFormatConfigArgs:
    def __init__(__self__, *,
                 prefix_config: pulumi.Input['FlowPrefixConfigArgs'],
                 aggregation_config: Optional[pulumi.Input['FlowAggregationConfigArgs']] = None,
                 file_type: Optional[pulumi.Input['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) -> pulumi.Input['FlowPrefixConfigArgs']:
        return pulumi.get(self, "prefix_config")

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

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

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

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

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


@pulumi.input_type
class FlowVeevaSourcePropertiesArgs:
    def __init__(__self__, *,
                 object: pulumi.Input[str],
                 document_type: Optional[pulumi.Input[str]] = None,
                 include_all_versions: Optional[pulumi.Input[bool]] = None,
                 include_renditions: Optional[pulumi.Input[bool]] = None,
                 include_source_files: Optional[pulumi.Input[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) -> pulumi.Input[str]:
        return pulumi.get(self, "object")

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class FlowZendeskDestinationPropertiesArgs:
    def __init__(__self__, *,
                 object: pulumi.Input[str],
                 error_handling_config: Optional[pulumi.Input['FlowErrorHandlingConfigArgs']] = None,
                 id_field_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 write_operation_type: Optional[pulumi.Input['FlowWriteOperationType']] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[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) -> pulumi.Input[str]:
        return pulumi.get(self, "object")

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

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

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

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

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

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

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


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

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

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


