Module types

The high-level entity that can be queried in Amazon AppFlow. For example, a Salesforce entity might be an Account or Opportunity, whereas a ServiceNow entity might be an Incident.

ConnectorEntityField

Describes the data model of a connector field. For example, for an account entity, the fields would be account name, account ID, and so on.

ConnectorMetadata

A structure to specify connector-specific metadata such as oAuthScopes, supportedRegions, privateLinkServiceUrl, and so on.

ConnectorOAuthRequest

Used by select connectors for which the OAuth workflow is supported, such as Salesforce, Google Analytics, Marketo, Zendesk, and Slack.

ConnectorOperator

The operation to be performed on the provided source fields.

ConnectorProfile

Describes an instance of a connector. This includes the provided name, credentials ARN, connection-mode, and so on. To keep the API intuitive and extensible, the fields that are common to all types of connector profiles are explicitly specified at the top level. The rest of the connector-specific properties are available via the connectorProfileProperties field.

ConnectorProfileConfig

Defines the connector-specific configuration and credentials for the connector profile.

ConnectorProfileCredentials

The connector-specific credentials required by a connector.

ConnectorProfileProperties

The connector-specific profile properties required by each connector.

ConnectorProvisioningConfig

Contains information about the configuration of the connector being registered.

ConnectorRuntimeSetting

Contains information about the connector runtime settings that are required for flow execution.

CustomAuthConfig

Configuration information required for custom authentication.

CustomAuthCredentials

The custom credentials required for custom authentication.

CustomConnectorDestinationProperties

The properties that are applied when the custom connector is being used as a destination.

CustomConnectorProfileCredentials

The connector-specific profile credentials that are required when using the custom connector.

CustomConnectorProfileProperties

The profile properties required by the custom connector.

CustomConnectorSourceProperties

The properties that are applied when the custom connector is being used as a source.

CustomerProfilesDestinationProperties

The properties that are applied when Amazon Connect Customer Profiles is used as a destination.

CustomerProfilesMetadata

The connector metadata specific to Amazon Connect Customer Profiles.

DataTransferApi

The API of the connector application that Amazon AppFlow uses to transfer your data.

DatadogConnectorProfileCredentials

The connector-specific credentials required by Datadog.

DatadogConnectorProfileProperties

The connector-specific profile properties required by Datadog.

DatadogMetadata

The connector metadata specific to Datadog.

DatadogSourceProperties

The properties that are applied when Datadog is being used as a source.

DestinationConnectorProperties

This stores the information that is required to query a particular connector.

DestinationFieldProperties

The properties that can be applied to a field when connector is being used as a destination.

DestinationFlowConfig

Contains information about the configuration of destination connectors present in the flow.

DynatraceConnectorProfileCredentials

The connector-specific profile credentials required by Dynatrace.

DynatraceConnectorProfileProperties

The connector-specific profile properties required by Dynatrace.

DynatraceMetadata

The connector metadata specific to Dynatrace.

DynatraceSourceProperties

The properties that are applied when Dynatrace is being used as a source.

ErrorHandlingConfig

The settings that determine how Amazon AppFlow handles an error when placing data in the destination. For example, this setting would determine if the flow should fail after one insertion error, or continue and attempt to insert every record regardless of the initial failure. ErrorHandlingConfig is a part of the destination connector details.

ErrorInfo

Provides details in the event of a failed flow, including the failure count and the related error messages.

EventBridgeDestinationProperties

The properties that are applied when Amazon EventBridge is being used as a destination.

EventBridgeMetadata

The connector metadata specific to Amazon EventBridge.

ExecutionDetails

Describes the details of the flow run, including the timestamp, status, and message.

ExecutionRecord

Specifies information about the past flow run instances for a given flow.

ExecutionResult

Specifies the end result of the flow run.

FieldTypeDetails

Contains details regarding the supported field type and the operators that can be applied for filtering.

FlowDefinition

The properties of the flow, such as its source, destination, trigger type, and so on.

GlueDataCatalogConfig

Specifies the configuration that Amazon AppFlow uses when it catalogs your data with the Glue Data Catalog. When Amazon AppFlow catalogs your data, it stores metadata in Data Catalog tables. This metadata represents the data that's transferred by the flow that you configure with these settings.

You can configure a flow with these settings only when the flow destination is Amazon S3.

GoogleAnalyticsConnectorProfileCredentials

The connector-specific profile credentials required by Google Analytics.

GoogleAnalyticsConnectorProfileProperties

The connector-specific profile properties required by Google Analytics.

GoogleAnalyticsMetadata

The connector metadata specific to Google Analytics.

GoogleAnalyticsSourceProperties

The properties that are applied when Google Analytics is being used as a source.

HoneycodeConnectorProfileCredentials

The connector-specific credentials required when using Amazon Honeycode.

HoneycodeConnectorProfileProperties

The connector-specific properties required when using Amazon Honeycode.

HoneycodeDestinationProperties

The properties that are applied when Amazon Honeycode is used as a destination.

HoneycodeMetadata

The connector metadata specific to Amazon Honeycode.

IncrementalPullConfig

Specifies the configuration used when importing incremental records from the source.

InforNexusConnectorProfileCredentials

The connector-specific profile credentials required by Infor Nexus.

InforNexusConnectorProfileProperties

The connector-specific profile properties required by Infor Nexus.

InforNexusMetadata

The connector metadata specific to Infor Nexus.

InforNexusSourceProperties

The properties that are applied when Infor Nexus is being used as a source.

LambdaConnectorProvisioningConfig

Contains information about the configuration of the lambda which is being registered as the connector.

LookoutMetricsDestinationProperties

The properties that are applied when Amazon Lookout for Metrics is used as a destination.

MarketoConnectorProfileCredentials

The connector-specific profile credentials required by Marketo.

MarketoConnectorProfileProperties

The connector-specific profile properties required when using Marketo.

MarketoDestinationProperties

The properties that Amazon AppFlow applies when you use Marketo as a flow destination.

MarketoMetadata

The connector metadata specific to Marketo.

MarketoSourceProperties

The properties that are applied when Marketo is being used as a source.

MetadataCatalogConfig

Specifies the configuration that Amazon AppFlow uses when it catalogs your data. When Amazon AppFlow catalogs your data, it stores metadata in a data catalog.

MetadataCatalogDetail

Describes the metadata catalog, metadata table, and data partitions that Amazon AppFlow used for the associated flow run.

OAuth2Credentials

The OAuth 2.0 credentials required for OAuth 2.0 authentication.

OAuth2CustomParameter

Custom parameter required for OAuth 2.0 authentication.

OAuth2Defaults

Contains the default values required for OAuth 2.0 authentication.

OAuth2Properties

The OAuth 2.0 properties required for OAuth 2.0 authentication.

OAuthCredentials

The OAuth credentials required for OAuth type authentication.

OAuthProperties

The OAuth properties required for OAuth type authentication.

PardotConnectorProfileCredentials

The connector-specific profile credentials required when using Salesforce Pardot.

PardotConnectorProfileProperties

The connector-specific profile properties required when using Salesforce Pardot.

PardotMetadata

The connector metadata specific to Salesforce Pardot.

PardotSourceProperties

The properties that are applied when Salesforce Pardot is being used as a source.

PrefixConfig

Specifies elements that Amazon AppFlow includes in the file and folder names in the flow destination.

PrivateConnectionProvisioningState

Specifies the private connection provisioning state.

Range

The range of values that the property supports.

RedshiftConnectorProfileCredentials

The connector-specific profile credentials required when using Amazon Redshift.

RedshiftConnectorProfileProperties

The connector-specific profile properties when using Amazon Redshift.

RedshiftDestinationProperties

The properties that are applied when Amazon Redshift is being used as a destination.

RedshiftMetadata

The connector metadata specific to Amazon Redshift.

RegistrationOutput

Describes the status of an attempt from Amazon AppFlow to register a resource.

When you run a flow that you've configured to use a metadata catalog, Amazon AppFlow registers a metadata table and data partitions with that catalog. This operation provides the status of that registration attempt. The operation also indicates how many related resources Amazon AppFlow created or updated.

S3DestinationProperties

The properties that are applied when Amazon S3 is used as a destination.

S3InputFormatConfig

When you use Amazon S3 as the source, the configuration format that you provide the flow input data.

S3Metadata

The connector metadata specific to Amazon S3.

S3OutputFormatConfig

The configuration that determines how Amazon AppFlow should format the flow output data when Amazon S3 is used as the destination.

S3SourceProperties

The properties that are applied when Amazon S3 is being used as the flow source.

SalesforceConnectorProfileCredentials

The connector-specific profile credentials required when using Salesforce.

SalesforceConnectorProfileProperties

The connector-specific profile properties required when using Salesforce.

SalesforceDestinationProperties

The properties that are applied when Salesforce is being used as a destination.

SalesforceMetadata

The connector metadata specific to Salesforce.

SalesforceSourceProperties

The properties that are applied when Salesforce is being used as a source.

SapoDataConnectorProfileCredentials

The connector-specific profile credentials required when using SAPOData.

SapoDataConnectorProfileProperties

The connector-specific profile properties required when using SAPOData.

SapoDataDestinationProperties

The properties that are applied when using SAPOData as a flow destination

SapoDataMetadata

The connector metadata specific to SAPOData.

SapoDataPaginationConfig

Sets the page size for each concurrent process that transfers OData records from your SAP instance. A concurrent process is query that retrieves a batch of records as part of a flow run. Amazon AppFlow can run multiple concurrent processes in parallel to transfer data faster.

SapoDataParallelismConfig

Sets the number of concurrent processes that transfer OData records from your SAP instance. A concurrent process is query that retrieves a batch of records as part of a flow run. Amazon AppFlow can run multiple concurrent processes in parallel to transfer data faster.

SapoDataSourceProperties

The properties that are applied when using SAPOData as a flow source.

ScheduledTriggerProperties

Specifies the configuration details of a schedule-triggered flow as defined by the user. Currently, these settings only apply to the Scheduled trigger type.

ServiceNowConnectorProfileCredentials

The connector-specific profile credentials required when using ServiceNow.

ServiceNowConnectorProfileProperties

The connector-specific profile properties required when using ServiceNow.

ServiceNowMetadata

The connector metadata specific to ServiceNow.

ServiceNowSourceProperties

The properties that are applied when ServiceNow is being used as a source.

SingularConnectorProfileCredentials

The connector-specific profile credentials required when using Singular.

SingularConnectorProfileProperties

The connector-specific profile properties required when using Singular.

SingularMetadata

The connector metadata specific to Singular.

SingularSourceProperties

The properties that are applied when Singular is being used as a source.

SlackConnectorProfileCredentials

The connector-specific profile credentials required when using Slack.

SlackConnectorProfileProperties

The connector-specific profile properties required when using Slack.

SlackMetadata

The connector metadata specific to Slack.

SlackSourceProperties

The properties that are applied when Slack is being used as a source.

SnowflakeConnectorProfileCredentials

The connector-specific profile credentials required when using Snowflake.

SnowflakeConnectorProfileProperties

The connector-specific profile properties required when using Snowflake.

SnowflakeDestinationProperties

The properties that are applied when Snowflake is being used as a destination.

SnowflakeMetadata

The connector metadata specific to Snowflake.

SourceConnectorProperties

Specifies the information that is required to query a particular connector.

SourceFieldProperties

The properties that can be applied to a field when the connector is being used as a source.

SourceFlowConfig

Contains information about the configuration of the source connector used in the flow.

SuccessResponseHandlingConfig

Determines how Amazon AppFlow handles the success response that it gets from the connector after placing data.

For example, this setting would determine where to write the response from the destination connector upon a successful insert operation.

SupportedFieldTypeDetails

Contains details regarding all the supported FieldTypes and their corresponding filterOperators and supportedValues.

Task

A class for modeling different type of tasks. Task implementation varies based on the TaskType.

TrendmicroConnectorProfileCredentials

The connector-specific profile credentials required when using Trend Micro.

TrendmicroConnectorProfileProperties

The connector-specific profile properties required when using Trend Micro.

TrendmicroMetadata

The connector metadata specific to Trend Micro.

TrendmicroSourceProperties

The properties that are applied when using Trend Micro as a flow source.

TriggerConfig

The trigger settings that determine how and when Amazon AppFlow runs the specified flow.

TriggerProperties

Specifies the configuration details that control the trigger for a flow. Currently, these settings only apply to the Scheduled trigger type.

UpsolverDestinationProperties

The properties that are applied when Upsolver is used as a destination.

UpsolverMetadata

The connector metadata specific to Upsolver.

UpsolverS3OutputFormatConfig

The configuration that determines how Amazon AppFlow formats the flow output data when Upsolver is used as the destination.

VeevaConnectorProfileCredentials

The connector-specific profile credentials required when using Veeva.

VeevaConnectorProfileProperties

The connector-specific profile properties required when using Veeva.

VeevaMetadata

The connector metadata specific to Veeva.

VeevaSourceProperties

The properties that are applied when using Veeva as a flow source.

ZendeskConnectorProfileCredentials

The connector-specific profile credentials required when using Zendesk.

ZendeskConnectorProfileProperties

The connector-specific profile properties required when using Zendesk.

ZendeskDestinationProperties

The properties that are applied when Zendesk is used as a destination.

ZendeskMetadata

The connector metadata specific to Zendesk.

ZendeskSourceProperties

The properties that are applied when using Zendesk as a flow source.

Enums§

AggregationType: When writing a match expression against AggregationType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
AmplitudeConnectorOperator: When writing a match expression against AmplitudeConnectorOperator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
AuthenticationType: When writing a match expression against AuthenticationType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
CatalogType: When writing a match expression against CatalogType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ConnectionMode: When writing a match expression against ConnectionMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ConnectorProvisioningType: When writing a match expression against ConnectorProvisioningType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ConnectorType: When writing a match expression against ConnectorType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
DataPullMode: When writing a match expression against DataPullMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
DataTransferApiType: When writing a match expression against DataTransferApiType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
DatadogConnectorOperator: When writing a match expression against DatadogConnectorOperator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
DynatraceConnectorOperator: When writing a match expression against DynatraceConnectorOperator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ExecutionStatus: When writing a match expression against ExecutionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
FileType: When writing a match expression against FileType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
FlowStatus: When writing a match expression against FlowStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
GoogleAnalyticsConnectorOperator: When writing a match expression against GoogleAnalyticsConnectorOperator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
InforNexusConnectorOperator: When writing a match expression against InforNexusConnectorOperator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
MarketoConnectorOperator: When writing a match expression against MarketoConnectorOperator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
OAuth2CustomPropType: When writing a match expression against OAuth2CustomPropType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
OAuth2GrantType: When writing a match expression against OAuth2GrantType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
Operator: When writing a match expression against Operator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
OperatorPropertiesKeys: When writing a match expression against OperatorPropertiesKeys, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
Operators: When writing a match expression against Operators, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
PardotConnectorOperator: When writing a match expression against PardotConnectorOperator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
PathPrefix: When writing a match expression against PathPrefix, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
PrefixFormat: When writing a match expression against PrefixFormat, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
PrefixType: When writing a match expression against PrefixType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
PrivateConnectionProvisioningFailureCause: When writing a match expression against PrivateConnectionProvisioningFailureCause, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
PrivateConnectionProvisioningStatus: When writing a match expression against PrivateConnectionProvisioningStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
S3ConnectorOperator: When writing a match expression against S3ConnectorOperator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
S3InputFileType: When writing a match expression against S3InputFileType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
SalesforceConnectorOperator: When writing a match expression against SalesforceConnectorOperator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
SalesforceDataTransferApi: When writing a match expression against SalesforceDataTransferApi, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
SapoDataConnectorOperator: When writing a match expression against SapoDataConnectorOperator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ScheduleFrequencyType: When writing a match expression against ScheduleFrequencyType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ServiceNowConnectorOperator: When writing a match expression against ServiceNowConnectorOperator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
SingularConnectorOperator: When writing a match expression against SingularConnectorOperator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
SlackConnectorOperator: When writing a match expression against SlackConnectorOperator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
SupportedDataTransferType: When writing a match expression against SupportedDataTransferType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
TaskType: When writing a match expression against TaskType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
TrendmicroConnectorOperator: When writing a match expression against TrendmicroConnectorOperator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
TriggerType: When writing a match expression against TriggerType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
VeevaConnectorOperator: When writing a match expression against VeevaConnectorOperator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
WriteOperationType: When writing a match expression against WriteOperationType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ZendeskConnectorOperator: When writing a match expression against ZendeskConnectorOperator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Module typesCopy item path

Modules§

Structs§

Enums§

Module types