Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AggregationConfig

type AggregationConfig struct {

	// Specifies whether Amazon AppFlow aggregates the flow records into a single file,
	// or leave them unaggregated.
	AggregationType AggregationType
}

    The aggregation settings that you can use to customize the output format of your flow data.

    type AggregationType

    type AggregationType string
    const (
    	AggregationTypeNone       AggregationType = "None"
    	AggregationTypeSingleFile AggregationType = "SingleFile"
    )

      Enum values for AggregationType

      func (AggregationType) Values

      func (AggregationType) Values() []AggregationType

        Values returns all known values for AggregationType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

        type AmplitudeConnectorOperator

        type AmplitudeConnectorOperator string
        const (
        	AmplitudeConnectorOperatorBetween AmplitudeConnectorOperator = "BETWEEN"
        )

          Enum values for AmplitudeConnectorOperator

          func (AmplitudeConnectorOperator) Values

            Values returns all known values for AmplitudeConnectorOperator. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

            type AmplitudeConnectorProfileCredentials

            type AmplitudeConnectorProfileCredentials struct {
            
            	// A unique alphanumeric identifier used to authenticate a user, developer, or
            	// calling program to your API.
            	//
            	// This member is required.
            	ApiKey *string
            
            	// The Secret Access Key portion of the credentials.
            	//
            	// This member is required.
            	SecretKey *string
            }

              The connector-specific credentials required when using Amplitude.

              type AmplitudeConnectorProfileProperties

              type AmplitudeConnectorProfileProperties struct {
              }

                The connector-specific profile properties required when using Amplitude.

                type AmplitudeMetadata

                type AmplitudeMetadata struct {
                }

                  The connector metadata specific to Amplitude.

                  type AmplitudeSourceProperties

                  type AmplitudeSourceProperties struct {
                  
                  	// The object specified in the Amplitude flow source.
                  	//
                  	// This member is required.
                  	Object *string
                  }

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

                    type ConflictException

                    type ConflictException struct {
                    	Message *string
                    }

                      There was a conflict when processing the request (for example, a flow with the given name already exists within the account. Check for conflicting resource names and try again.

                      func (*ConflictException) Error

                      func (e *ConflictException) Error() string

                      func (*ConflictException) ErrorCode

                      func (e *ConflictException) ErrorCode() string

                      func (*ConflictException) ErrorFault

                      func (e *ConflictException) ErrorFault() smithy.ErrorFault

                      func (*ConflictException) ErrorMessage

                      func (e *ConflictException) ErrorMessage() string

                      type ConnectionMode

                      type ConnectionMode string
                      const (
                      	ConnectionModePublic  ConnectionMode = "Public"
                      	ConnectionModePrivate ConnectionMode = "Private"
                      )

                        Enum values for ConnectionMode

                        func (ConnectionMode) Values

                        func (ConnectionMode) Values() []ConnectionMode

                          Values returns all known values for ConnectionMode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                          type ConnectorAuthenticationException

                          type ConnectorAuthenticationException struct {
                          	Message *string
                          }

                            An error occurred when authenticating with the connector endpoint.

                            func (*ConnectorAuthenticationException) Error

                            func (*ConnectorAuthenticationException) ErrorCode

                            func (*ConnectorAuthenticationException) ErrorFault

                            func (*ConnectorAuthenticationException) ErrorMessage

                            func (e *ConnectorAuthenticationException) ErrorMessage() string

                            type ConnectorConfiguration

                            type ConnectorConfiguration struct {
                            
                            	// Specifies whether the connector can be used as a destination.
                            	CanUseAsDestination bool
                            
                            	// Specifies whether the connector can be used as a source.
                            	CanUseAsSource bool
                            
                            	// Specifies connector-specific metadata such as oAuthScopes, supportedRegions,
                            	// privateLinkServiceUrl, and so on.
                            	ConnectorMetadata *ConnectorMetadata
                            
                            	// Specifies if PrivateLink is enabled for that connector.
                            	IsPrivateLinkEnabled bool
                            
                            	// Specifies if a PrivateLink endpoint URL is required.
                            	IsPrivateLinkEndpointUrlRequired bool
                            
                            	// Lists the connectors that are available for use as destinations.
                            	SupportedDestinationConnectors []ConnectorType
                            
                            	// Specifies the supported flow frequency for that connector.
                            	SupportedSchedulingFrequencies []ScheduleFrequencyType
                            
                            	// Specifies the supported trigger types for the flow.
                            	SupportedTriggerTypes []TriggerType
                            }

                              The configuration settings related to a given connector.

                              type ConnectorEntity

                              type ConnectorEntity struct {
                              
                              	// The name of the connector entity.
                              	//
                              	// This member is required.
                              	Name *string
                              
                              	// Specifies whether the connector entity is a parent or a category and has more
                              	// entities nested underneath it. If another call is made with entitiesPath =
                              	// "the_current_entity_name_with_hasNestedEntities_true", then it returns the
                              	// nested entities underneath it. This provides a way to retrieve all supported
                              	// entities in a recursive fashion.
                              	HasNestedEntities bool
                              
                              	// The label applied to the connector entity.
                              	Label *string
                              }

                                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.

                                type ConnectorEntityField

                                type ConnectorEntityField struct {
                                
                                	// The unique identifier of the connector field.
                                	//
                                	// This member is required.
                                	Identifier *string
                                
                                	// A description of the connector entity field.
                                	Description *string
                                
                                	// The properties applied to a field when the connector is being used as a
                                	// destination.
                                	DestinationProperties *DestinationFieldProperties
                                
                                	// The label applied to a connector entity field.
                                	Label *string
                                
                                	// The properties that can be applied to a field when the connector is being used
                                	// as a source.
                                	SourceProperties *SourceFieldProperties
                                
                                	// Contains details regarding the supported FieldType, including the corresponding
                                	// filterOperators and supportedValues.
                                	SupportedFieldTypeDetails *SupportedFieldTypeDetails
                                }

                                  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.

                                  type ConnectorMetadata

                                  type ConnectorMetadata struct {
                                  
                                  	// The connector metadata specific to Amplitude.
                                  	Amplitude *AmplitudeMetadata
                                  
                                  	// The connector metadata specific to Datadog.
                                  	Datadog *DatadogMetadata
                                  
                                  	// The connector metadata specific to Dynatrace.
                                  	Dynatrace *DynatraceMetadata
                                  
                                  	// The connector metadata specific to Amazon EventBridge.
                                  	EventBridge *EventBridgeMetadata
                                  
                                  	// The connector metadata specific to Google Analytics.
                                  	GoogleAnalytics *GoogleAnalyticsMetadata
                                  
                                  	// The connector metadata specific to Infor Nexus.
                                  	InforNexus *InforNexusMetadata
                                  
                                  	// The connector metadata specific to Marketo.
                                  	Marketo *MarketoMetadata
                                  
                                  	// The connector metadata specific to Amazon Redshift.
                                  	Redshift *RedshiftMetadata
                                  
                                  	// The connector metadata specific to Amazon S3.
                                  	S3 *S3Metadata
                                  
                                  	// The connector metadata specific to Salesforce.
                                  	Salesforce *SalesforceMetadata
                                  
                                  	// The connector metadata specific to ServiceNow.
                                  	ServiceNow *ServiceNowMetadata
                                  
                                  	// The connector metadata specific to Singular.
                                  	Singular *SingularMetadata
                                  
                                  	// The connector metadata specific to Slack.
                                  	Slack *SlackMetadata
                                  
                                  	// The connector metadata specific to Snowflake.
                                  	Snowflake *SnowflakeMetadata
                                  
                                  	// The connector metadata specific to Trend Micro.
                                  	Trendmicro *TrendmicroMetadata
                                  
                                  	// The connector metadata specific to Upsolver.
                                  	Upsolver *UpsolverMetadata
                                  
                                  	// The connector metadata specific to Veeva.
                                  	Veeva *VeevaMetadata
                                  
                                  	// The connector metadata specific to Zendesk.
                                  	Zendesk *ZendeskMetadata
                                  }

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

                                    type ConnectorOAuthRequest

                                    type ConnectorOAuthRequest struct {
                                    
                                    	// The code provided by the connector when it has been authenticated via the
                                    	// connected app.
                                    	AuthCode *string
                                    
                                    	// The URL to which the authentication server redirects the browser after
                                    	// authorization has been granted.
                                    	RedirectUri *string
                                    }

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

                                      type ConnectorOperator

                                      type ConnectorOperator struct {
                                      
                                      	// The operation to be performed on the provided Amplitude source fields.
                                      	Amplitude AmplitudeConnectorOperator
                                      
                                      	// The operation to be performed on the provided Datadog source fields.
                                      	Datadog DatadogConnectorOperator
                                      
                                      	// The operation to be performed on the provided Dynatrace source fields.
                                      	Dynatrace DynatraceConnectorOperator
                                      
                                      	// The operation to be performed on the provided Google Analytics source fields.
                                      	GoogleAnalytics GoogleAnalyticsConnectorOperator
                                      
                                      	// The operation to be performed on the provided Infor Nexus source fields.
                                      	InforNexus InforNexusConnectorOperator
                                      
                                      	// The operation to be performed on the provided Marketo source fields.
                                      	Marketo MarketoConnectorOperator
                                      
                                      	// The operation to be performed on the provided Amazon S3 source fields.
                                      	S3 S3ConnectorOperator
                                      
                                      	// The operation to be performed on the provided Salesforce source fields.
                                      	Salesforce SalesforceConnectorOperator
                                      
                                      	// The operation to be performed on the provided ServiceNow source fields.
                                      	ServiceNow ServiceNowConnectorOperator
                                      
                                      	// The operation to be performed on the provided Singular source fields.
                                      	Singular SingularConnectorOperator
                                      
                                      	// The operation to be performed on the provided Slack source fields.
                                      	Slack SlackConnectorOperator
                                      
                                      	// The operation to be performed on the provided Trend Micro source fields.
                                      	Trendmicro TrendmicroConnectorOperator
                                      
                                      	// The operation to be performed on the provided Veeva source fields.
                                      	Veeva VeevaConnectorOperator
                                      
                                      	// The operation to be performed on the provided Zendesk source fields.
                                      	Zendesk ZendeskConnectorOperator
                                      }

                                        The operation to be performed on the provided source fields.

                                        type ConnectorProfile

                                        type ConnectorProfile struct {
                                        
                                        	// Indicates the connection mode and if it is public or private.
                                        	ConnectionMode ConnectionMode
                                        
                                        	// The Amazon Resource Name (ARN) of the connector profile.
                                        	ConnectorProfileArn *string
                                        
                                        	// The name of the connector profile. The name is unique for each ConnectorProfile
                                        	// in the AWS account.
                                        	ConnectorProfileName *string
                                        
                                        	// The connector-specific properties of the profile configuration.
                                        	ConnectorProfileProperties *ConnectorProfileProperties
                                        
                                        	// The type of connector, such as Salesforce, Amplitude, and so on.
                                        	ConnectorType ConnectorType
                                        
                                        	// Specifies when the connector profile was created.
                                        	CreatedAt *time.Time
                                        
                                        	// The Amazon Resource Name (ARN) of the connector profile credentials.
                                        	CredentialsArn *string
                                        
                                        	// Specifies when the connector profile was last updated.
                                        	LastUpdatedAt *time.Time
                                        }

                                          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.

                                          type ConnectorProfileConfig

                                          type ConnectorProfileConfig struct {
                                          
                                          	// The connector-specific credentials required by each connector.
                                          	//
                                          	// This member is required.
                                          	ConnectorProfileCredentials *ConnectorProfileCredentials
                                          
                                          	// The connector-specific properties of the profile configuration.
                                          	//
                                          	// This member is required.
                                          	ConnectorProfileProperties *ConnectorProfileProperties
                                          }

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

                                            type ConnectorProfileCredentials

                                            type ConnectorProfileCredentials struct {
                                            
                                            	// The connector-specific credentials required when using Amplitude.
                                            	Amplitude *AmplitudeConnectorProfileCredentials
                                            
                                            	// The connector-specific credentials required when using Datadog.
                                            	Datadog *DatadogConnectorProfileCredentials
                                            
                                            	// The connector-specific credentials required when using Dynatrace.
                                            	Dynatrace *DynatraceConnectorProfileCredentials
                                            
                                            	// The connector-specific credentials required when using Google Analytics.
                                            	GoogleAnalytics *GoogleAnalyticsConnectorProfileCredentials
                                            
                                            	// The connector-specific credentials required when using Infor Nexus.
                                            	InforNexus *InforNexusConnectorProfileCredentials
                                            
                                            	// The connector-specific credentials required when using Marketo.
                                            	Marketo *MarketoConnectorProfileCredentials
                                            
                                            	// The connector-specific credentials required when using Amazon Redshift.
                                            	Redshift *RedshiftConnectorProfileCredentials
                                            
                                            	// The connector-specific credentials required when using Salesforce.
                                            	Salesforce *SalesforceConnectorProfileCredentials
                                            
                                            	// The connector-specific credentials required when using ServiceNow.
                                            	ServiceNow *ServiceNowConnectorProfileCredentials
                                            
                                            	// The connector-specific credentials required when using Singular.
                                            	Singular *SingularConnectorProfileCredentials
                                            
                                            	// The connector-specific credentials required when using Slack.
                                            	Slack *SlackConnectorProfileCredentials
                                            
                                            	// The connector-specific credentials required when using Snowflake.
                                            	Snowflake *SnowflakeConnectorProfileCredentials
                                            
                                            	// The connector-specific credentials required when using Trend Micro.
                                            	Trendmicro *TrendmicroConnectorProfileCredentials
                                            
                                            	// The connector-specific credentials required when using Veeva.
                                            	Veeva *VeevaConnectorProfileCredentials
                                            
                                            	// The connector-specific credentials required when using Zendesk.
                                            	Zendesk *ZendeskConnectorProfileCredentials
                                            }

                                              The connector-specific credentials required by a connector.

                                              type ConnectorProfileProperties

                                              type ConnectorProfileProperties struct {
                                              
                                              	// The connector-specific properties required by Amplitude.
                                              	Amplitude *AmplitudeConnectorProfileProperties
                                              
                                              	// The connector-specific properties required by Datadog.
                                              	Datadog *DatadogConnectorProfileProperties
                                              
                                              	// The connector-specific properties required by Dynatrace.
                                              	Dynatrace *DynatraceConnectorProfileProperties
                                              
                                              	// The connector-specific properties required Google Analytics.
                                              	GoogleAnalytics *GoogleAnalyticsConnectorProfileProperties
                                              
                                              	// The connector-specific properties required by Infor Nexus.
                                              	InforNexus *InforNexusConnectorProfileProperties
                                              
                                              	// The connector-specific properties required by Marketo.
                                              	Marketo *MarketoConnectorProfileProperties
                                              
                                              	// The connector-specific properties required by Amazon Redshift.
                                              	Redshift *RedshiftConnectorProfileProperties
                                              
                                              	// The connector-specific properties required by Salesforce.
                                              	Salesforce *SalesforceConnectorProfileProperties
                                              
                                              	// The connector-specific properties required by serviceNow.
                                              	ServiceNow *ServiceNowConnectorProfileProperties
                                              
                                              	// The connector-specific properties required by Singular.
                                              	Singular *SingularConnectorProfileProperties
                                              
                                              	// The connector-specific properties required by Slack.
                                              	Slack *SlackConnectorProfileProperties
                                              
                                              	// The connector-specific properties required by Snowflake.
                                              	Snowflake *SnowflakeConnectorProfileProperties
                                              
                                              	// The connector-specific properties required by Trend Micro.
                                              	Trendmicro *TrendmicroConnectorProfileProperties
                                              
                                              	// The connector-specific properties required by Veeva.
                                              	Veeva *VeevaConnectorProfileProperties
                                              
                                              	// The connector-specific properties required by Zendesk.
                                              	Zendesk *ZendeskConnectorProfileProperties
                                              }

                                                The connector-specific profile properties required by each connector.

                                                type ConnectorServerException

                                                type ConnectorServerException struct {
                                                	Message *string
                                                }

                                                  An error occurred when retrieving data from the connector endpoint.

                                                  func (*ConnectorServerException) Error

                                                  func (e *ConnectorServerException) Error() string

                                                  func (*ConnectorServerException) ErrorCode

                                                  func (e *ConnectorServerException) ErrorCode() string

                                                  func (*ConnectorServerException) ErrorFault

                                                  func (e *ConnectorServerException) ErrorFault() smithy.ErrorFault

                                                  func (*ConnectorServerException) ErrorMessage

                                                  func (e *ConnectorServerException) ErrorMessage() string

                                                  type ConnectorType

                                                  type ConnectorType string
                                                  const (
                                                  	ConnectorTypeSalesforce      ConnectorType = "Salesforce"
                                                  	ConnectorTypeSingular        ConnectorType = "Singular"
                                                  	ConnectorTypeSlack           ConnectorType = "Slack"
                                                  	ConnectorTypeRedshift        ConnectorType = "Redshift"
                                                  	ConnectorTypeS3              ConnectorType = "S3"
                                                  	ConnectorTypeMarketo         ConnectorType = "Marketo"
                                                  	ConnectorTypeGoogleanalytics ConnectorType = "Googleanalytics"
                                                  	ConnectorTypeZendesk         ConnectorType = "Zendesk"
                                                  	ConnectorTypeServicenow      ConnectorType = "Servicenow"
                                                  	ConnectorTypeDatadog         ConnectorType = "Datadog"
                                                  	ConnectorTypeTrendmicro      ConnectorType = "Trendmicro"
                                                  	ConnectorTypeSnowflake       ConnectorType = "Snowflake"
                                                  	ConnectorTypeDynatrace       ConnectorType = "Dynatrace"
                                                  	ConnectorTypeInfornexus      ConnectorType = "Infornexus"
                                                  	ConnectorTypeAmplitude       ConnectorType = "Amplitude"
                                                  	ConnectorTypeVeeva           ConnectorType = "Veeva"
                                                  	ConnectorTypeEventbridge     ConnectorType = "EventBridge"
                                                  	ConnectorTypeUpsolver        ConnectorType = "Upsolver"
                                                  )

                                                    Enum values for ConnectorType

                                                    func (ConnectorType) Values

                                                    func (ConnectorType) Values() []ConnectorType

                                                      Values returns all known values for ConnectorType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                      type DataPullMode

                                                      type DataPullMode string
                                                      const (
                                                      	DataPullModeIncremental DataPullMode = "Incremental"
                                                      	DataPullModeComplete    DataPullMode = "Complete"
                                                      )

                                                        Enum values for DataPullMode

                                                        func (DataPullMode) Values

                                                        func (DataPullMode) Values() []DataPullMode

                                                          Values returns all known values for DataPullMode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                          type DatadogConnectorOperator

                                                          type DatadogConnectorOperator string
                                                          const (
                                                          	DatadogConnectorOperatorProjection          DatadogConnectorOperator = "PROJECTION"
                                                          	DatadogConnectorOperatorBetween             DatadogConnectorOperator = "BETWEEN"
                                                          	DatadogConnectorOperatorEqualTo             DatadogConnectorOperator = "EQUAL_TO"
                                                          	DatadogConnectorOperatorAddition            DatadogConnectorOperator = "ADDITION"
                                                          	DatadogConnectorOperatorMultiplication      DatadogConnectorOperator = "MULTIPLICATION"
                                                          	DatadogConnectorOperatorDivision            DatadogConnectorOperator = "DIVISION"
                                                          	DatadogConnectorOperatorSubtraction         DatadogConnectorOperator = "SUBTRACTION"
                                                          	DatadogConnectorOperatorMaskAll             DatadogConnectorOperator = "MASK_ALL"
                                                          	DatadogConnectorOperatorMaskFirstN          DatadogConnectorOperator = "MASK_FIRST_N"
                                                          	DatadogConnectorOperatorMaskLastN           DatadogConnectorOperator = "MASK_LAST_N"
                                                          	DatadogConnectorOperatorValidateNonNull     DatadogConnectorOperator = "VALIDATE_NON_NULL"
                                                          	DatadogConnectorOperatorValidateNonZero     DatadogConnectorOperator = "VALIDATE_NON_ZERO"
                                                          	DatadogConnectorOperatorValidateNonNegative DatadogConnectorOperator = "VALIDATE_NON_NEGATIVE"
                                                          	DatadogConnectorOperatorValidateNumeric     DatadogConnectorOperator = "VALIDATE_NUMERIC"
                                                          	DatadogConnectorOperatorNoOp                DatadogConnectorOperator = "NO_OP"
                                                          )

                                                            Enum values for DatadogConnectorOperator

                                                            func (DatadogConnectorOperator) Values

                                                              Values returns all known values for DatadogConnectorOperator. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                              type DatadogConnectorProfileCredentials

                                                              type DatadogConnectorProfileCredentials struct {
                                                              
                                                              	// A unique alphanumeric identifier used to authenticate a user, developer, or
                                                              	// calling program to your API.
                                                              	//
                                                              	// This member is required.
                                                              	ApiKey *string
                                                              
                                                              	// 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.
                                                              	//
                                                              	// This member is required.
                                                              	ApplicationKey *string
                                                              }

                                                                The connector-specific credentials required by Datadog.

                                                                type DatadogConnectorProfileProperties

                                                                type DatadogConnectorProfileProperties struct {
                                                                
                                                                	// The location of the Datadog resource.
                                                                	//
                                                                	// This member is required.
                                                                	InstanceUrl *string
                                                                }

                                                                  The connector-specific profile properties required by Datadog.

                                                                  type DatadogMetadata

                                                                  type DatadogMetadata struct {
                                                                  }

                                                                    The connector metadata specific to Datadog.

                                                                    type DatadogSourceProperties

                                                                    type DatadogSourceProperties struct {
                                                                    
                                                                    	// The object specified in the Datadog flow source.
                                                                    	//
                                                                    	// This member is required.
                                                                    	Object *string
                                                                    }

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

                                                                      type DestinationConnectorProperties

                                                                      type DestinationConnectorProperties struct {
                                                                      
                                                                      	// The properties required to query Amazon EventBridge.
                                                                      	EventBridge *EventBridgeDestinationProperties
                                                                      
                                                                      	// The properties required to query Amazon Redshift.
                                                                      	Redshift *RedshiftDestinationProperties
                                                                      
                                                                      	// The properties required to query Amazon S3.
                                                                      	S3 *S3DestinationProperties
                                                                      
                                                                      	// The properties required to query Salesforce.
                                                                      	Salesforce *SalesforceDestinationProperties
                                                                      
                                                                      	// The properties required to query Snowflake.
                                                                      	Snowflake *SnowflakeDestinationProperties
                                                                      
                                                                      	// The properties required to query Upsolver.
                                                                      	Upsolver *UpsolverDestinationProperties
                                                                      }

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

                                                                        type DestinationFieldProperties

                                                                        type DestinationFieldProperties struct {
                                                                        
                                                                        	// Specifies if the destination field can be created by the current user.
                                                                        	IsCreatable bool
                                                                        
                                                                        	// Specifies if the destination field can have a null value.
                                                                        	IsNullable bool
                                                                        
                                                                        	// Specifies whether the field can be updated during an UPDATE or UPSERT write
                                                                        	// operation.
                                                                        	IsUpdatable bool
                                                                        
                                                                        	// Specifies if the flow run can either insert new rows in the destination field if
                                                                        	// they do not already exist, or update them if they do.
                                                                        	IsUpsertable bool
                                                                        
                                                                        	// A list of supported write operations. For each write operation listed, this
                                                                        	// field can be used in idFieldNames when that write operation is present as a
                                                                        	// destination option.
                                                                        	SupportedWriteOperations []WriteOperationType
                                                                        }

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

                                                                          type DestinationFlowConfig

                                                                          type DestinationFlowConfig struct {
                                                                          
                                                                          	// The type of connector, such as Salesforce, Amplitude, and so on.
                                                                          	//
                                                                          	// This member is required.
                                                                          	ConnectorType ConnectorType
                                                                          
                                                                          	// This stores the information that is required to query a particular connector.
                                                                          	//
                                                                          	// This member is required.
                                                                          	DestinationConnectorProperties *DestinationConnectorProperties
                                                                          
                                                                          	// The name of the connector profile. This name must be unique for each connector
                                                                          	// profile in the AWS account.
                                                                          	ConnectorProfileName *string
                                                                          }

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

                                                                            type DynatraceConnectorOperator

                                                                            type DynatraceConnectorOperator string
                                                                            const (
                                                                            	DynatraceConnectorOperatorProjection          DynatraceConnectorOperator = "PROJECTION"
                                                                            	DynatraceConnectorOperatorBetween             DynatraceConnectorOperator = "BETWEEN"
                                                                            	DynatraceConnectorOperatorEqualTo             DynatraceConnectorOperator = "EQUAL_TO"
                                                                            	DynatraceConnectorOperatorAddition            DynatraceConnectorOperator = "ADDITION"
                                                                            	DynatraceConnectorOperatorMultiplication      DynatraceConnectorOperator = "MULTIPLICATION"
                                                                            	DynatraceConnectorOperatorDivision            DynatraceConnectorOperator = "DIVISION"
                                                                            	DynatraceConnectorOperatorSubtraction         DynatraceConnectorOperator = "SUBTRACTION"
                                                                            	DynatraceConnectorOperatorMaskAll             DynatraceConnectorOperator = "MASK_ALL"
                                                                            	DynatraceConnectorOperatorMaskFirstN          DynatraceConnectorOperator = "MASK_FIRST_N"
                                                                            	DynatraceConnectorOperatorMaskLastN           DynatraceConnectorOperator = "MASK_LAST_N"
                                                                            	DynatraceConnectorOperatorValidateNonNull     DynatraceConnectorOperator = "VALIDATE_NON_NULL"
                                                                            	DynatraceConnectorOperatorValidateNonZero     DynatraceConnectorOperator = "VALIDATE_NON_ZERO"
                                                                            	DynatraceConnectorOperatorValidateNonNegative DynatraceConnectorOperator = "VALIDATE_NON_NEGATIVE"
                                                                            	DynatraceConnectorOperatorValidateNumeric     DynatraceConnectorOperator = "VALIDATE_NUMERIC"
                                                                            	DynatraceConnectorOperatorNoOp                DynatraceConnectorOperator = "NO_OP"
                                                                            )

                                                                              Enum values for DynatraceConnectorOperator

                                                                              func (DynatraceConnectorOperator) Values

                                                                                Values returns all known values for DynatraceConnectorOperator. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                type DynatraceConnectorProfileCredentials

                                                                                type DynatraceConnectorProfileCredentials struct {
                                                                                
                                                                                	// The API tokens used by Dynatrace API to authenticate various API calls.
                                                                                	//
                                                                                	// This member is required.
                                                                                	ApiToken *string
                                                                                }

                                                                                  The connector-specific profile credentials required by Dynatrace.

                                                                                  type DynatraceConnectorProfileProperties

                                                                                  type DynatraceConnectorProfileProperties struct {
                                                                                  
                                                                                  	// The location of the Dynatrace resource.
                                                                                  	//
                                                                                  	// This member is required.
                                                                                  	InstanceUrl *string
                                                                                  }

                                                                                    The connector-specific profile properties required by Dynatrace.

                                                                                    type DynatraceMetadata

                                                                                    type DynatraceMetadata struct {
                                                                                    }

                                                                                      The connector metadata specific to Dynatrace.

                                                                                      type DynatraceSourceProperties

                                                                                      type DynatraceSourceProperties struct {
                                                                                      
                                                                                      	// The object specified in the Dynatrace flow source.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	Object *string
                                                                                      }

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

                                                                                        type ErrorHandlingConfig

                                                                                        type ErrorHandlingConfig struct {
                                                                                        
                                                                                        	// Specifies the name of the Amazon S3 bucket.
                                                                                        	BucketName *string
                                                                                        
                                                                                        	// Specifies the Amazon S3 bucket prefix.
                                                                                        	BucketPrefix *string
                                                                                        
                                                                                        	// Specifies if the flow should fail after the first instance of a failure when
                                                                                        	// attempting to place data in the destination.
                                                                                        	FailOnFirstDestinationError bool
                                                                                        }

                                                                                          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.

                                                                                          type ErrorInfo

                                                                                          type ErrorInfo struct {
                                                                                          
                                                                                          	// Specifies the error message that appears if a flow fails.
                                                                                          	ExecutionMessage *string
                                                                                          
                                                                                          	// Specifies the failure count for the attempted flow.
                                                                                          	PutFailuresCount *int64
                                                                                          }

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

                                                                                            type EventBridgeDestinationProperties

                                                                                            type EventBridgeDestinationProperties struct {
                                                                                            
                                                                                            	// The object specified in the Amazon EventBridge flow destination.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Object *string
                                                                                            
                                                                                            	// 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.
                                                                                            	ErrorHandlingConfig *ErrorHandlingConfig
                                                                                            }

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

                                                                                              type EventBridgeMetadata

                                                                                              type EventBridgeMetadata struct {
                                                                                              }

                                                                                                The connector metadata specific to Amazon EventBridge.

                                                                                                type ExecutionDetails

                                                                                                type ExecutionDetails struct {
                                                                                                
                                                                                                	// Describes the details of the most recent flow run.
                                                                                                	MostRecentExecutionMessage *string
                                                                                                
                                                                                                	// Specifies the status of the most recent flow run.
                                                                                                	MostRecentExecutionStatus ExecutionStatus
                                                                                                
                                                                                                	// Specifies the time of the most recent flow run.
                                                                                                	MostRecentExecutionTime *time.Time
                                                                                                }

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

                                                                                                  type ExecutionRecord

                                                                                                  type ExecutionRecord struct {
                                                                                                  
                                                                                                  	// Specifies the identifier of the given flow run.
                                                                                                  	ExecutionId *string
                                                                                                  
                                                                                                  	// Describes the result of the given flow run.
                                                                                                  	ExecutionResult *ExecutionResult
                                                                                                  
                                                                                                  	// Specifies the flow run status and whether it is in progress, has completed
                                                                                                  	// successfully, or has failed.
                                                                                                  	ExecutionStatus ExecutionStatus
                                                                                                  
                                                                                                  	// Specifies the time of the most recent update.
                                                                                                  	LastUpdatedAt *time.Time
                                                                                                  
                                                                                                  	// Specifies the start time of the flow run.
                                                                                                  	StartedAt *time.Time
                                                                                                  }

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

                                                                                                    type ExecutionResult

                                                                                                    type ExecutionResult struct {
                                                                                                    
                                                                                                    	// The total number of bytes processed by the flow run.
                                                                                                    	BytesProcessed *int64
                                                                                                    
                                                                                                    	// The total number of bytes written as a result of the flow run.
                                                                                                    	BytesWritten *int64
                                                                                                    
                                                                                                    	// Provides any error message information related to the flow run.
                                                                                                    	ErrorInfo *ErrorInfo
                                                                                                    
                                                                                                    	// The number of records processed in the flow run.
                                                                                                    	RecordsProcessed *int64
                                                                                                    }

                                                                                                      Specifies the end result of the flow run.

                                                                                                      type ExecutionStatus

                                                                                                      type ExecutionStatus string
                                                                                                      const (
                                                                                                      	ExecutionStatusInprogress ExecutionStatus = "InProgress"
                                                                                                      	ExecutionStatusSuccessful ExecutionStatus = "Successful"
                                                                                                      	ExecutionStatusError      ExecutionStatus = "Error"
                                                                                                      )

                                                                                                        Enum values for ExecutionStatus

                                                                                                        func (ExecutionStatus) Values

                                                                                                        func (ExecutionStatus) Values() []ExecutionStatus

                                                                                                          Values returns all known values for ExecutionStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                          type FieldTypeDetails

                                                                                                          type FieldTypeDetails struct {
                                                                                                          
                                                                                                          	// The type of field, such as string, integer, date, and so on.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	FieldType *string
                                                                                                          
                                                                                                          	// The list of operators supported by a field.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	FilterOperators []Operator
                                                                                                          
                                                                                                          	// The list of values that a field can contain. For example, a Boolean fieldType
                                                                                                          	// can have two values: "true" and "false".
                                                                                                          	SupportedValues []string
                                                                                                          }

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

                                                                                                            type FileType

                                                                                                            type FileType string
                                                                                                            const (
                                                                                                            	FileTypeCsv     FileType = "CSV"
                                                                                                            	FileTypeJson    FileType = "JSON"
                                                                                                            	FileTypeParquet FileType = "PARQUET"
                                                                                                            )

                                                                                                              Enum values for FileType

                                                                                                              func (FileType) Values

                                                                                                              func (FileType) Values() []FileType

                                                                                                                Values returns all known values for FileType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                type FlowDefinition

                                                                                                                type FlowDefinition struct {
                                                                                                                
                                                                                                                	// Specifies when the flow was created.
                                                                                                                	CreatedAt *time.Time
                                                                                                                
                                                                                                                	// The ARN of the user who created the flow.
                                                                                                                	CreatedBy *string
                                                                                                                
                                                                                                                	// A user-entered description of the flow.
                                                                                                                	Description *string
                                                                                                                
                                                                                                                	// Specifies the destination connector type, such as Salesforce, Amazon S3,
                                                                                                                	// Amplitude, and so on.
                                                                                                                	DestinationConnectorType ConnectorType
                                                                                                                
                                                                                                                	// The flow's Amazon Resource Name (ARN).
                                                                                                                	FlowArn *string
                                                                                                                
                                                                                                                	// The specified name of the flow. Spaces are not allowed. Use underscores (_) or
                                                                                                                	// hyphens (-) only.
                                                                                                                	FlowName *string
                                                                                                                
                                                                                                                	// Indicates the current status of the flow.
                                                                                                                	FlowStatus FlowStatus
                                                                                                                
                                                                                                                	// Describes the details of the most recent flow run.
                                                                                                                	LastRunExecutionDetails *ExecutionDetails
                                                                                                                
                                                                                                                	// Specifies when the flow was last updated.
                                                                                                                	LastUpdatedAt *time.Time
                                                                                                                
                                                                                                                	// Specifies the account user name that most recently updated the flow.
                                                                                                                	LastUpdatedBy *string
                                                                                                                
                                                                                                                	// Specifies the source connector type, such as Salesforce, Amazon S3, Amplitude,
                                                                                                                	// and so on.
                                                                                                                	SourceConnectorType ConnectorType
                                                                                                                
                                                                                                                	// The tags used to organize, track, or control access for your flow.
                                                                                                                	Tags map[string]string
                                                                                                                
                                                                                                                	// Specifies the type of flow trigger. This can be OnDemand, Scheduled, or Event.
                                                                                                                	TriggerType TriggerType
                                                                                                                }

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

                                                                                                                  type FlowStatus

                                                                                                                  type FlowStatus string
                                                                                                                  const (
                                                                                                                  	FlowStatusActive     FlowStatus = "Active"
                                                                                                                  	FlowStatusDeprecated FlowStatus = "Deprecated"
                                                                                                                  	FlowStatusDeleted    FlowStatus = "Deleted"
                                                                                                                  	FlowStatusDraft      FlowStatus = "Draft"
                                                                                                                  	FlowStatusErrored    FlowStatus = "Errored"
                                                                                                                  	FlowStatusSuspended  FlowStatus = "Suspended"
                                                                                                                  )

                                                                                                                    Enum values for FlowStatus

                                                                                                                    func (FlowStatus) Values

                                                                                                                    func (FlowStatus) Values() []FlowStatus

                                                                                                                      Values returns all known values for FlowStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                      type GoogleAnalyticsConnectorOperator

                                                                                                                      type GoogleAnalyticsConnectorOperator string
                                                                                                                      const (
                                                                                                                      	GoogleAnalyticsConnectorOperatorProjection GoogleAnalyticsConnectorOperator = "PROJECTION"
                                                                                                                      	GoogleAnalyticsConnectorOperatorBetween    GoogleAnalyticsConnectorOperator = "BETWEEN"
                                                                                                                      )

                                                                                                                        Enum values for GoogleAnalyticsConnectorOperator

                                                                                                                        func (GoogleAnalyticsConnectorOperator) Values

                                                                                                                          Values returns all known values for GoogleAnalyticsConnectorOperator. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                          type GoogleAnalyticsConnectorProfileCredentials

                                                                                                                          type GoogleAnalyticsConnectorProfileCredentials struct {
                                                                                                                          
                                                                                                                          	// The identifier for the desired client.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	ClientId *string
                                                                                                                          
                                                                                                                          	// The client secret used by the OAuth client to authenticate to the authorization
                                                                                                                          	// server.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	ClientSecret *string
                                                                                                                          
                                                                                                                          	// The credentials used to access protected Google Analytics resources.
                                                                                                                          	AccessToken *string
                                                                                                                          
                                                                                                                          	// The OAuth requirement needed to request security tokens from the connector
                                                                                                                          	// endpoint.
                                                                                                                          	OAuthRequest *ConnectorOAuthRequest
                                                                                                                          
                                                                                                                          	// The credentials used to acquire new access tokens. This is required only for
                                                                                                                          	// OAuth2 access tokens, and is not required for OAuth1 access tokens.
                                                                                                                          	RefreshToken *string
                                                                                                                          }

                                                                                                                            The connector-specific profile credentials required by Google Analytics.

                                                                                                                            type GoogleAnalyticsConnectorProfileProperties

                                                                                                                            type GoogleAnalyticsConnectorProfileProperties struct {
                                                                                                                            }

                                                                                                                              The connector-specific profile properties required by Google Analytics.

                                                                                                                              type GoogleAnalyticsMetadata

                                                                                                                              type GoogleAnalyticsMetadata struct {
                                                                                                                              
                                                                                                                              	// The desired authorization scope for the Google Analytics account.
                                                                                                                              	OAuthScopes []string
                                                                                                                              }

                                                                                                                                The connector metadata specific to Google Analytics.

                                                                                                                                type GoogleAnalyticsSourceProperties

                                                                                                                                type GoogleAnalyticsSourceProperties struct {
                                                                                                                                
                                                                                                                                	// The object specified in the Google Analytics flow source.
                                                                                                                                	//
                                                                                                                                	// This member is required.
                                                                                                                                	Object *string
                                                                                                                                }

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

                                                                                                                                  type IncrementalPullConfig

                                                                                                                                  type IncrementalPullConfig struct {
                                                                                                                                  
                                                                                                                                  	// A field that specifies the date time or timestamp field as the criteria to use
                                                                                                                                  	// when importing incremental records from the source.
                                                                                                                                  	DatetimeTypeFieldName *string
                                                                                                                                  }

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

                                                                                                                                    type InforNexusConnectorOperator

                                                                                                                                    type InforNexusConnectorOperator string
                                                                                                                                    const (
                                                                                                                                    	InforNexusConnectorOperatorProjection          InforNexusConnectorOperator = "PROJECTION"
                                                                                                                                    	InforNexusConnectorOperatorBetween             InforNexusConnectorOperator = "BETWEEN"
                                                                                                                                    	InforNexusConnectorOperatorEqualTo             InforNexusConnectorOperator = "EQUAL_TO"
                                                                                                                                    	InforNexusConnectorOperatorAddition            InforNexusConnectorOperator = "ADDITION"
                                                                                                                                    	InforNexusConnectorOperatorMultiplication      InforNexusConnectorOperator = "MULTIPLICATION"
                                                                                                                                    	InforNexusConnectorOperatorDivision            InforNexusConnectorOperator = "DIVISION"
                                                                                                                                    	InforNexusConnectorOperatorSubtraction         InforNexusConnectorOperator = "SUBTRACTION"
                                                                                                                                    	InforNexusConnectorOperatorMaskAll             InforNexusConnectorOperator = "MASK_ALL"
                                                                                                                                    	InforNexusConnectorOperatorMaskFirstN          InforNexusConnectorOperator = "MASK_FIRST_N"
                                                                                                                                    	InforNexusConnectorOperatorMaskLastN           InforNexusConnectorOperator = "MASK_LAST_N"
                                                                                                                                    	InforNexusConnectorOperatorValidateNonNull     InforNexusConnectorOperator = "VALIDATE_NON_NULL"
                                                                                                                                    	InforNexusConnectorOperatorValidateNonZero     InforNexusConnectorOperator = "VALIDATE_NON_ZERO"
                                                                                                                                    	InforNexusConnectorOperatorValidateNonNegative InforNexusConnectorOperator = "VALIDATE_NON_NEGATIVE"
                                                                                                                                    	InforNexusConnectorOperatorValidateNumeric     InforNexusConnectorOperator = "VALIDATE_NUMERIC"
                                                                                                                                    	InforNexusConnectorOperatorNoOp                InforNexusConnectorOperator = "NO_OP"
                                                                                                                                    )

                                                                                                                                      Enum values for InforNexusConnectorOperator

                                                                                                                                      func (InforNexusConnectorOperator) Values

                                                                                                                                        Values returns all known values for InforNexusConnectorOperator. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                        type InforNexusConnectorProfileCredentials

                                                                                                                                        type InforNexusConnectorProfileCredentials struct {
                                                                                                                                        
                                                                                                                                        	// The Access Key portion of the credentials.
                                                                                                                                        	//
                                                                                                                                        	// This member is required.
                                                                                                                                        	AccessKeyId *string
                                                                                                                                        
                                                                                                                                        	// The encryption keys used to encrypt data.
                                                                                                                                        	//
                                                                                                                                        	// This member is required.
                                                                                                                                        	Datakey *string
                                                                                                                                        
                                                                                                                                        	// The secret key used to sign requests.
                                                                                                                                        	//
                                                                                                                                        	// This member is required.
                                                                                                                                        	SecretAccessKey *string
                                                                                                                                        
                                                                                                                                        	// The identifier for the user.
                                                                                                                                        	//
                                                                                                                                        	// This member is required.
                                                                                                                                        	UserId *string
                                                                                                                                        }

                                                                                                                                          The connector-specific profile credentials required by Infor Nexus.

                                                                                                                                          type InforNexusConnectorProfileProperties

                                                                                                                                          type InforNexusConnectorProfileProperties struct {
                                                                                                                                          
                                                                                                                                          	// The location of the Infor Nexus resource.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	InstanceUrl *string
                                                                                                                                          }

                                                                                                                                            The connector-specific profile properties required by Infor Nexus.

                                                                                                                                            type InforNexusMetadata

                                                                                                                                            type InforNexusMetadata struct {
                                                                                                                                            }

                                                                                                                                              The connector metadata specific to Infor Nexus.

                                                                                                                                              type InforNexusSourceProperties

                                                                                                                                              type InforNexusSourceProperties struct {
                                                                                                                                              
                                                                                                                                              	// The object specified in the Infor Nexus flow source.
                                                                                                                                              	//
                                                                                                                                              	// This member is required.
                                                                                                                                              	Object *string
                                                                                                                                              }

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

                                                                                                                                                type InternalServerException

                                                                                                                                                type InternalServerException struct {
                                                                                                                                                	Message *string
                                                                                                                                                }

                                                                                                                                                  An internal service error occurred during the processing of your request. Try again later.

                                                                                                                                                  func (*InternalServerException) Error

                                                                                                                                                  func (e *InternalServerException) Error() string

                                                                                                                                                  func (*InternalServerException) ErrorCode

                                                                                                                                                  func (e *InternalServerException) ErrorCode() string

                                                                                                                                                  func (*InternalServerException) ErrorFault

                                                                                                                                                  func (e *InternalServerException) ErrorFault() smithy.ErrorFault

                                                                                                                                                  func (*InternalServerException) ErrorMessage

                                                                                                                                                  func (e *InternalServerException) ErrorMessage() string

                                                                                                                                                  type MarketoConnectorOperator

                                                                                                                                                  type MarketoConnectorOperator string
                                                                                                                                                  const (
                                                                                                                                                  	MarketoConnectorOperatorProjection          MarketoConnectorOperator = "PROJECTION"
                                                                                                                                                  	MarketoConnectorOperatorLessThan            MarketoConnectorOperator = "LESS_THAN"
                                                                                                                                                  	MarketoConnectorOperatorGreaterThan         MarketoConnectorOperator = "GREATER_THAN"
                                                                                                                                                  	MarketoConnectorOperatorBetween             MarketoConnectorOperator = "BETWEEN"
                                                                                                                                                  	MarketoConnectorOperatorAddition            MarketoConnectorOperator = "ADDITION"
                                                                                                                                                  	MarketoConnectorOperatorMultiplication      MarketoConnectorOperator = "MULTIPLICATION"
                                                                                                                                                  	MarketoConnectorOperatorDivision            MarketoConnectorOperator = "DIVISION"
                                                                                                                                                  	MarketoConnectorOperatorSubtraction         MarketoConnectorOperator = "SUBTRACTION"
                                                                                                                                                  	MarketoConnectorOperatorMaskAll             MarketoConnectorOperator = "MASK_ALL"
                                                                                                                                                  	MarketoConnectorOperatorMaskFirstN          MarketoConnectorOperator = "MASK_FIRST_N"
                                                                                                                                                  	MarketoConnectorOperatorMaskLastN           MarketoConnectorOperator = "MASK_LAST_N"
                                                                                                                                                  	MarketoConnectorOperatorValidateNonNull     MarketoConnectorOperator = "VALIDATE_NON_NULL"
                                                                                                                                                  	MarketoConnectorOperatorValidateNonZero     MarketoConnectorOperator = "VALIDATE_NON_ZERO"
                                                                                                                                                  	MarketoConnectorOperatorValidateNonNegative MarketoConnectorOperator = "VALIDATE_NON_NEGATIVE"
                                                                                                                                                  	MarketoConnectorOperatorValidateNumeric     MarketoConnectorOperator = "VALIDATE_NUMERIC"
                                                                                                                                                  	MarketoConnectorOperatorNoOp                MarketoConnectorOperator = "NO_OP"
                                                                                                                                                  )

                                                                                                                                                    Enum values for MarketoConnectorOperator

                                                                                                                                                    func (MarketoConnectorOperator) Values

                                                                                                                                                      Values returns all known values for MarketoConnectorOperator. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                      type MarketoConnectorProfileCredentials

                                                                                                                                                      type MarketoConnectorProfileCredentials struct {
                                                                                                                                                      
                                                                                                                                                      	// The identifier for the desired client.
                                                                                                                                                      	//
                                                                                                                                                      	// This member is required.
                                                                                                                                                      	ClientId *string
                                                                                                                                                      
                                                                                                                                                      	// The client secret used by the OAuth client to authenticate to the authorization
                                                                                                                                                      	// server.
                                                                                                                                                      	//
                                                                                                                                                      	// This member is required.
                                                                                                                                                      	ClientSecret *string
                                                                                                                                                      
                                                                                                                                                      	// The credentials used to access protected Marketo resources.
                                                                                                                                                      	AccessToken *string
                                                                                                                                                      
                                                                                                                                                      	// The OAuth requirement needed to request security tokens from the connector
                                                                                                                                                      	// endpoint.
                                                                                                                                                      	OAuthRequest *ConnectorOAuthRequest
                                                                                                                                                      }

                                                                                                                                                        The connector-specific profile credentials required by Marketo.

                                                                                                                                                        type MarketoConnectorProfileProperties

                                                                                                                                                        type MarketoConnectorProfileProperties struct {
                                                                                                                                                        
                                                                                                                                                        	// The location of the Marketo resource.
                                                                                                                                                        	//
                                                                                                                                                        	// This member is required.
                                                                                                                                                        	InstanceUrl *string
                                                                                                                                                        }

                                                                                                                                                          The connector-specific profile properties required when using Marketo.

                                                                                                                                                          type MarketoMetadata

                                                                                                                                                          type MarketoMetadata struct {
                                                                                                                                                          }

                                                                                                                                                            The connector metadata specific to Marketo.

                                                                                                                                                            type MarketoSourceProperties

                                                                                                                                                            type MarketoSourceProperties struct {
                                                                                                                                                            
                                                                                                                                                            	// The object specified in the Marketo flow source.
                                                                                                                                                            	//
                                                                                                                                                            	// This member is required.
                                                                                                                                                            	Object *string
                                                                                                                                                            }

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

                                                                                                                                                              type Operator

                                                                                                                                                              type Operator string
                                                                                                                                                              const (
                                                                                                                                                              	OperatorProjection           Operator = "PROJECTION"
                                                                                                                                                              	OperatorLessThan             Operator = "LESS_THAN"
                                                                                                                                                              	OperatorGreaterThan          Operator = "GREATER_THAN"
                                                                                                                                                              	OperatorContains             Operator = "CONTAINS"
                                                                                                                                                              	OperatorBetween              Operator = "BETWEEN"
                                                                                                                                                              	OperatorLessThanOrEqualTo    Operator = "LESS_THAN_OR_EQUAL_TO"
                                                                                                                                                              	OperatorGreaterThanOrEqualTo Operator = "GREATER_THAN_OR_EQUAL_TO"
                                                                                                                                                              	OperatorEqualTo              Operator = "EQUAL_TO"
                                                                                                                                                              	OperatorNotEqualTo           Operator = "NOT_EQUAL_TO"
                                                                                                                                                              	OperatorAddition             Operator = "ADDITION"
                                                                                                                                                              	OperatorMultiplication       Operator = "MULTIPLICATION"
                                                                                                                                                              	OperatorDivision             Operator = "DIVISION"
                                                                                                                                                              	OperatorSubtraction          Operator = "SUBTRACTION"
                                                                                                                                                              	OperatorMaskAll              Operator = "MASK_ALL"
                                                                                                                                                              	OperatorMaskFirstN           Operator = "MASK_FIRST_N"
                                                                                                                                                              	OperatorMaskLastN            Operator = "MASK_LAST_N"
                                                                                                                                                              	OperatorValidateNonNull      Operator = "VALIDATE_NON_NULL"
                                                                                                                                                              	OperatorValidateNonZero      Operator = "VALIDATE_NON_ZERO"
                                                                                                                                                              	OperatorValidateNonNegative  Operator = "VALIDATE_NON_NEGATIVE"
                                                                                                                                                              	OperatorValidateNumeric      Operator = "VALIDATE_NUMERIC"
                                                                                                                                                              	OperatorNoOp                 Operator = "NO_OP"
                                                                                                                                                              )

                                                                                                                                                                Enum values for Operator

                                                                                                                                                                func (Operator) Values

                                                                                                                                                                func (Operator) Values() []Operator

                                                                                                                                                                  Values returns all known values for Operator. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                  type OperatorPropertiesKeys

                                                                                                                                                                  type OperatorPropertiesKeys string
                                                                                                                                                                  const (
                                                                                                                                                                  	OperatorPropertiesKeysValue                    OperatorPropertiesKeys = "VALUE"
                                                                                                                                                                  	OperatorPropertiesKeysValues                   OperatorPropertiesKeys = "VALUES"
                                                                                                                                                                  	OperatorPropertiesKeysDataType                 OperatorPropertiesKeys = "DATA_TYPE"
                                                                                                                                                                  	OperatorPropertiesKeysUpperBound               OperatorPropertiesKeys = "UPPER_BOUND"
                                                                                                                                                                  	OperatorPropertiesKeysLowerBound               OperatorPropertiesKeys = "LOWER_BOUND"
                                                                                                                                                                  	OperatorPropertiesKeysSourceDataType           OperatorPropertiesKeys = "SOURCE_DATA_TYPE"
                                                                                                                                                                  	OperatorPropertiesKeysDestinationDataType      OperatorPropertiesKeys = "DESTINATION_DATA_TYPE"
                                                                                                                                                                  	OperatorPropertiesKeysValidationAction         OperatorPropertiesKeys = "VALIDATION_ACTION"
                                                                                                                                                                  	OperatorPropertiesKeysMaskValue                OperatorPropertiesKeys = "MASK_VALUE"
                                                                                                                                                                  	OperatorPropertiesKeysMaskLength               OperatorPropertiesKeys = "MASK_LENGTH"
                                                                                                                                                                  	OperatorPropertiesKeysTruncateLength           OperatorPropertiesKeys = "TRUNCATE_LENGTH"
                                                                                                                                                                  	OperatorPropertiesKeysMathOperationFieldsOrder OperatorPropertiesKeys = "MATH_OPERATION_FIELDS_ORDER"
                                                                                                                                                                  	OperatorPropertiesKeysConcatFormat             OperatorPropertiesKeys = "CONCAT_FORMAT"
                                                                                                                                                                  	OperatorPropertiesKeysSubfieldCategoryMap      OperatorPropertiesKeys = "SUBFIELD_CATEGORY_MAP"
                                                                                                                                                                  )

                                                                                                                                                                    Enum values for OperatorPropertiesKeys

                                                                                                                                                                    func (OperatorPropertiesKeys) Values

                                                                                                                                                                      Values returns all known values for OperatorPropertiesKeys. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                      type PrefixConfig

                                                                                                                                                                      type PrefixConfig struct {
                                                                                                                                                                      
                                                                                                                                                                      	// Determines the format of the prefix, and whether it applies to the file name,
                                                                                                                                                                      	// file path, or both.
                                                                                                                                                                      	PrefixFormat PrefixFormat
                                                                                                                                                                      
                                                                                                                                                                      	// Determines the level of granularity that's included in the prefix.
                                                                                                                                                                      	PrefixType PrefixType
                                                                                                                                                                      }

                                                                                                                                                                        Determines the prefix that Amazon AppFlow applies to the destination folder name. You can name your destination folders according to the flow frequency and date.

                                                                                                                                                                        type PrefixFormat

                                                                                                                                                                        type PrefixFormat string
                                                                                                                                                                        const (
                                                                                                                                                                        	PrefixFormatYear   PrefixFormat = "YEAR"
                                                                                                                                                                        	PrefixFormatMonth  PrefixFormat = "MONTH"
                                                                                                                                                                        	PrefixFormatDay    PrefixFormat = "DAY"
                                                                                                                                                                        	PrefixFormatHour   PrefixFormat = "HOUR"
                                                                                                                                                                        	PrefixFormatMinute PrefixFormat = "MINUTE"
                                                                                                                                                                        )

                                                                                                                                                                          Enum values for PrefixFormat

                                                                                                                                                                          func (PrefixFormat) Values

                                                                                                                                                                          func (PrefixFormat) Values() []PrefixFormat

                                                                                                                                                                            Values returns all known values for PrefixFormat. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                            type PrefixType

                                                                                                                                                                            type PrefixType string
                                                                                                                                                                            const (
                                                                                                                                                                            	PrefixTypeFilename        PrefixType = "FILENAME"
                                                                                                                                                                            	PrefixTypePath            PrefixType = "PATH"
                                                                                                                                                                            	PrefixTypePathAndFilename PrefixType = "PATH_AND_FILENAME"
                                                                                                                                                                            )

                                                                                                                                                                              Enum values for PrefixType

                                                                                                                                                                              func (PrefixType) Values

                                                                                                                                                                              func (PrefixType) Values() []PrefixType

                                                                                                                                                                                Values returns all known values for PrefixType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                type RedshiftConnectorProfileCredentials

                                                                                                                                                                                type RedshiftConnectorProfileCredentials struct {
                                                                                                                                                                                
                                                                                                                                                                                	// The password that corresponds to the user name.
                                                                                                                                                                                	//
                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                	Password *string
                                                                                                                                                                                
                                                                                                                                                                                	// The name of the user.
                                                                                                                                                                                	//
                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                	Username *string
                                                                                                                                                                                }

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

                                                                                                                                                                                  type RedshiftConnectorProfileProperties

                                                                                                                                                                                  type RedshiftConnectorProfileProperties struct {
                                                                                                                                                                                  
                                                                                                                                                                                  	// A name for the associated Amazon S3 bucket.
                                                                                                                                                                                  	//
                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                  	BucketName *string
                                                                                                                                                                                  
                                                                                                                                                                                  	// The JDBC URL of the Amazon Redshift cluster.
                                                                                                                                                                                  	//
                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                  	DatabaseUrl *string
                                                                                                                                                                                  
                                                                                                                                                                                  	// The Amazon Resource Name (ARN) of the IAM role.
                                                                                                                                                                                  	//
                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                  	RoleArn *string
                                                                                                                                                                                  
                                                                                                                                                                                  	// The object key for the destination bucket in which Amazon AppFlow places the
                                                                                                                                                                                  	// files.
                                                                                                                                                                                  	BucketPrefix *string
                                                                                                                                                                                  }

                                                                                                                                                                                    The connector-specific profile properties when using Amazon Redshift.

                                                                                                                                                                                    type RedshiftDestinationProperties

                                                                                                                                                                                    type RedshiftDestinationProperties struct {
                                                                                                                                                                                    
                                                                                                                                                                                    	// The intermediate bucket that Amazon AppFlow uses when moving data into Amazon
                                                                                                                                                                                    	// Redshift.
                                                                                                                                                                                    	//
                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                    	IntermediateBucketName *string
                                                                                                                                                                                    
                                                                                                                                                                                    	// The object specified in the Amazon Redshift flow destination.
                                                                                                                                                                                    	//
                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                    	Object *string
                                                                                                                                                                                    
                                                                                                                                                                                    	// The object key for the bucket in which Amazon AppFlow places the destination
                                                                                                                                                                                    	// files.
                                                                                                                                                                                    	BucketPrefix *string
                                                                                                                                                                                    
                                                                                                                                                                                    	// The settings that determine how Amazon AppFlow handles an error when placing
                                                                                                                                                                                    	// data in the Amazon Redshift 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.
                                                                                                                                                                                    	ErrorHandlingConfig *ErrorHandlingConfig
                                                                                                                                                                                    }

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

                                                                                                                                                                                      type RedshiftMetadata

                                                                                                                                                                                      type RedshiftMetadata struct {
                                                                                                                                                                                      }

                                                                                                                                                                                        The connector metadata specific to Amazon Redshift.

                                                                                                                                                                                        type ResourceNotFoundException

                                                                                                                                                                                        type ResourceNotFoundException struct {
                                                                                                                                                                                        	Message *string
                                                                                                                                                                                        }

                                                                                                                                                                                          The resource specified in the request (such as the source or destination connector profile) is not found.

                                                                                                                                                                                          func (*ResourceNotFoundException) Error

                                                                                                                                                                                          func (e *ResourceNotFoundException) Error() string

                                                                                                                                                                                          func (*ResourceNotFoundException) ErrorCode

                                                                                                                                                                                          func (e *ResourceNotFoundException) ErrorCode() string

                                                                                                                                                                                          func (*ResourceNotFoundException) ErrorFault

                                                                                                                                                                                          func (*ResourceNotFoundException) ErrorMessage

                                                                                                                                                                                          func (e *ResourceNotFoundException) ErrorMessage() string

                                                                                                                                                                                          type S3ConnectorOperator

                                                                                                                                                                                          type S3ConnectorOperator string
                                                                                                                                                                                          const (
                                                                                                                                                                                          	S3ConnectorOperatorProjection           S3ConnectorOperator = "PROJECTION"
                                                                                                                                                                                          	S3ConnectorOperatorLessThan             S3ConnectorOperator = "LESS_THAN"
                                                                                                                                                                                          	S3ConnectorOperatorGreaterThan          S3ConnectorOperator = "GREATER_THAN"
                                                                                                                                                                                          	S3ConnectorOperatorBetween              S3ConnectorOperator = "BETWEEN"
                                                                                                                                                                                          	S3ConnectorOperatorLessThanOrEqualTo    S3ConnectorOperator = "LESS_THAN_OR_EQUAL_TO"
                                                                                                                                                                                          	S3ConnectorOperatorGreaterThanOrEqualTo S3ConnectorOperator = "GREATER_THAN_OR_EQUAL_TO"
                                                                                                                                                                                          	S3ConnectorOperatorEqualTo              S3ConnectorOperator = "EQUAL_TO"
                                                                                                                                                                                          	S3ConnectorOperatorNotEqualTo           S3ConnectorOperator = "NOT_EQUAL_TO"
                                                                                                                                                                                          	S3ConnectorOperatorAddition             S3ConnectorOperator = "ADDITION"
                                                                                                                                                                                          	S3ConnectorOperatorMultiplication       S3ConnectorOperator = "MULTIPLICATION"
                                                                                                                                                                                          	S3ConnectorOperatorDivision             S3ConnectorOperator = "DIVISION"
                                                                                                                                                                                          	S3ConnectorOperatorSubtraction          S3ConnectorOperator = "SUBTRACTION"
                                                                                                                                                                                          	S3ConnectorOperatorMaskAll              S3ConnectorOperator = "MASK_ALL"
                                                                                                                                                                                          	S3ConnectorOperatorMaskFirstN           S3ConnectorOperator = "MASK_FIRST_N"
                                                                                                                                                                                          	S3ConnectorOperatorMaskLastN            S3ConnectorOperator = "MASK_LAST_N"
                                                                                                                                                                                          	S3ConnectorOperatorValidateNonNull      S3ConnectorOperator = "VALIDATE_NON_NULL"
                                                                                                                                                                                          	S3ConnectorOperatorValidateNonZero      S3ConnectorOperator = "VALIDATE_NON_ZERO"
                                                                                                                                                                                          	S3ConnectorOperatorValidateNonNegative  S3ConnectorOperator = "VALIDATE_NON_NEGATIVE"
                                                                                                                                                                                          	S3ConnectorOperatorValidateNumeric      S3ConnectorOperator = "VALIDATE_NUMERIC"
                                                                                                                                                                                          	S3ConnectorOperatorNoOp                 S3ConnectorOperator = "NO_OP"
                                                                                                                                                                                          )

                                                                                                                                                                                            Enum values for S3ConnectorOperator

                                                                                                                                                                                            func (S3ConnectorOperator) Values

                                                                                                                                                                                              Values returns all known values for S3ConnectorOperator. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                              type S3DestinationProperties

                                                                                                                                                                                              type S3DestinationProperties struct {
                                                                                                                                                                                              
                                                                                                                                                                                              	// The Amazon S3 bucket name in which Amazon AppFlow places the transferred data.
                                                                                                                                                                                              	//
                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                              	BucketName *string
                                                                                                                                                                                              
                                                                                                                                                                                              	// The object key for the destination bucket in which Amazon AppFlow places the
                                                                                                                                                                                              	// files.
                                                                                                                                                                                              	BucketPrefix *string
                                                                                                                                                                                              
                                                                                                                                                                                              	// The configuration that determines how Amazon AppFlow should format the flow
                                                                                                                                                                                              	// output data when Amazon S3 is used as the destination.
                                                                                                                                                                                              	S3OutputFormatConfig *S3OutputFormatConfig
                                                                                                                                                                                              }

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

                                                                                                                                                                                                type S3Metadata

                                                                                                                                                                                                type S3Metadata struct {
                                                                                                                                                                                                }

                                                                                                                                                                                                  The connector metadata specific to Amazon S3.

                                                                                                                                                                                                  type S3OutputFormatConfig

                                                                                                                                                                                                  type S3OutputFormatConfig struct {
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The aggregation settings that you can use to customize the output format of your
                                                                                                                                                                                                  	// flow data.
                                                                                                                                                                                                  	AggregationConfig *AggregationConfig
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// Indicates the file type that Amazon AppFlow places in the Amazon S3 bucket.
                                                                                                                                                                                                  	FileType FileType
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// Determines the prefix that Amazon AppFlow applies to the folder name in the
                                                                                                                                                                                                  	// Amazon S3 bucket. You can name folders according to the flow frequency and date.
                                                                                                                                                                                                  	PrefixConfig *PrefixConfig
                                                                                                                                                                                                  }

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

                                                                                                                                                                                                    type S3SourceProperties

                                                                                                                                                                                                    type S3SourceProperties struct {
                                                                                                                                                                                                    
                                                                                                                                                                                                    	// The Amazon S3 bucket name where the source files are stored.
                                                                                                                                                                                                    	//
                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                    	BucketName *string
                                                                                                                                                                                                    
                                                                                                                                                                                                    	// The object key for the Amazon S3 bucket in which the source files are stored.
                                                                                                                                                                                                    	BucketPrefix *string
                                                                                                                                                                                                    }

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

                                                                                                                                                                                                      type SalesforceConnectorOperator

                                                                                                                                                                                                      type SalesforceConnectorOperator string
                                                                                                                                                                                                      const (
                                                                                                                                                                                                      	SalesforceConnectorOperatorProjection           SalesforceConnectorOperator = "PROJECTION"
                                                                                                                                                                                                      	SalesforceConnectorOperatorLessThan             SalesforceConnectorOperator = "LESS_THAN"
                                                                                                                                                                                                      	SalesforceConnectorOperatorContains             SalesforceConnectorOperator = "CONTAINS"
                                                                                                                                                                                                      	SalesforceConnectorOperatorGreaterThan          SalesforceConnectorOperator = "GREATER_THAN"
                                                                                                                                                                                                      	SalesforceConnectorOperatorBetween              SalesforceConnectorOperator = "BETWEEN"
                                                                                                                                                                                                      	SalesforceConnectorOperatorLessThanOrEqualTo    SalesforceConnectorOperator = "LESS_THAN_OR_EQUAL_TO"
                                                                                                                                                                                                      	SalesforceConnectorOperatorGreaterThanOrEqualTo SalesforceConnectorOperator = "GREATER_THAN_OR_EQUAL_TO"
                                                                                                                                                                                                      	SalesforceConnectorOperatorEqualTo              SalesforceConnectorOperator = "EQUAL_TO"
                                                                                                                                                                                                      	SalesforceConnectorOperatorNotEqualTo           SalesforceConnectorOperator = "NOT_EQUAL_TO"
                                                                                                                                                                                                      	SalesforceConnectorOperatorAddition             SalesforceConnectorOperator = "ADDITION"
                                                                                                                                                                                                      	SalesforceConnectorOperatorMultiplication       SalesforceConnectorOperator = "MULTIPLICATION"
                                                                                                                                                                                                      	SalesforceConnectorOperatorDivision             SalesforceConnectorOperator = "DIVISION"
                                                                                                                                                                                                      	SalesforceConnectorOperatorSubtraction          SalesforceConnectorOperator = "SUBTRACTION"
                                                                                                                                                                                                      	SalesforceConnectorOperatorMaskAll              SalesforceConnectorOperator = "MASK_ALL"
                                                                                                                                                                                                      	SalesforceConnectorOperatorMaskFirstN           SalesforceConnectorOperator = "MASK_FIRST_N"
                                                                                                                                                                                                      	SalesforceConnectorOperatorMaskLastN            SalesforceConnectorOperator = "MASK_LAST_N"
                                                                                                                                                                                                      	SalesforceConnectorOperatorValidateNonNull      SalesforceConnectorOperator = "VALIDATE_NON_NULL"
                                                                                                                                                                                                      	SalesforceConnectorOperatorValidateNonZero      SalesforceConnectorOperator = "VALIDATE_NON_ZERO"
                                                                                                                                                                                                      	SalesforceConnectorOperatorValidateNonNegative  SalesforceConnectorOperator = "VALIDATE_NON_NEGATIVE"
                                                                                                                                                                                                      	SalesforceConnectorOperatorValidateNumeric      SalesforceConnectorOperator = "VALIDATE_NUMERIC"
                                                                                                                                                                                                      	SalesforceConnectorOperatorNoOp                 SalesforceConnectorOperator = "NO_OP"
                                                                                                                                                                                                      )

                                                                                                                                                                                                        Enum values for SalesforceConnectorOperator

                                                                                                                                                                                                        func (SalesforceConnectorOperator) Values

                                                                                                                                                                                                          Values returns all known values for SalesforceConnectorOperator. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                          type SalesforceConnectorProfileCredentials

                                                                                                                                                                                                          type SalesforceConnectorProfileCredentials struct {
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// The credentials used to access protected Salesforce resources.
                                                                                                                                                                                                          	AccessToken *string
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// The secret manager ARN, which contains the client ID and client secret of the
                                                                                                                                                                                                          	// connected app.
                                                                                                                                                                                                          	ClientCredentialsArn *string
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// The OAuth requirement needed to request security tokens from the connector
                                                                                                                                                                                                          	// endpoint.
                                                                                                                                                                                                          	OAuthRequest *ConnectorOAuthRequest
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// The credentials used to acquire new access tokens.
                                                                                                                                                                                                          	RefreshToken *string
                                                                                                                                                                                                          }

                                                                                                                                                                                                            The connector-specific profile credentials required when using Salesforce.

                                                                                                                                                                                                            type SalesforceConnectorProfileProperties

                                                                                                                                                                                                            type SalesforceConnectorProfileProperties struct {
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// The location of the Salesforce resource.
                                                                                                                                                                                                            	InstanceUrl *string
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// Indicates whether the connector profile applies to a sandbox or production
                                                                                                                                                                                                            	// environment.
                                                                                                                                                                                                            	IsSandboxEnvironment bool
                                                                                                                                                                                                            }

                                                                                                                                                                                                              The connector-specific profile properties required when using Salesforce.

                                                                                                                                                                                                              type SalesforceDestinationProperties

                                                                                                                                                                                                              type SalesforceDestinationProperties struct {
                                                                                                                                                                                                              
                                                                                                                                                                                                              	// The object specified in the Salesforce flow destination.
                                                                                                                                                                                                              	//
                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                              	Object *string
                                                                                                                                                                                                              
                                                                                                                                                                                                              	// The settings that determine how Amazon AppFlow handles an error when placing
                                                                                                                                                                                                              	// data in the Salesforce 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.
                                                                                                                                                                                                              	ErrorHandlingConfig *ErrorHandlingConfig
                                                                                                                                                                                                              
                                                                                                                                                                                                              	// The name of the field that Amazon AppFlow uses as an ID when performing a write
                                                                                                                                                                                                              	// operation such as update or delete.
                                                                                                                                                                                                              	IdFieldNames []string
                                                                                                                                                                                                              
                                                                                                                                                                                                              	// This specifies the type of write operation to be performed in Salesforce. When
                                                                                                                                                                                                              	// the value is UPSERT, then idFieldNames is required.
                                                                                                                                                                                                              	WriteOperationType WriteOperationType
                                                                                                                                                                                                              }

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

                                                                                                                                                                                                                type SalesforceMetadata

                                                                                                                                                                                                                type SalesforceMetadata struct {
                                                                                                                                                                                                                
                                                                                                                                                                                                                	// The desired authorization scope for the Salesforce account.
                                                                                                                                                                                                                	OAuthScopes []string
                                                                                                                                                                                                                }

                                                                                                                                                                                                                  The connector metadata specific to Salesforce.

                                                                                                                                                                                                                  type SalesforceSourceProperties

                                                                                                                                                                                                                  type SalesforceSourceProperties struct {
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// The object specified in the Salesforce flow source.
                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                  	Object *string
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// The flag that enables dynamic fetching of new (recently added) fields in the
                                                                                                                                                                                                                  	// Salesforce objects while running a flow.
                                                                                                                                                                                                                  	EnableDynamicFieldUpdate bool
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// Indicates whether Amazon AppFlow includes deleted files in the flow run.
                                                                                                                                                                                                                  	IncludeDeletedRecords bool
                                                                                                                                                                                                                  }

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

                                                                                                                                                                                                                    type ScheduleFrequencyType

                                                                                                                                                                                                                    type ScheduleFrequencyType string
                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                    	ScheduleFrequencyTypeByminute ScheduleFrequencyType = "BYMINUTE"
                                                                                                                                                                                                                    	ScheduleFrequencyTypeHourly   ScheduleFrequencyType = "HOURLY"
                                                                                                                                                                                                                    	ScheduleFrequencyTypeDaily    ScheduleFrequencyType = "DAILY"
                                                                                                                                                                                                                    	ScheduleFrequencyTypeWeekly   ScheduleFrequencyType = "WEEKLY"
                                                                                                                                                                                                                    	ScheduleFrequencyTypeMonthly  ScheduleFrequencyType = "MONTHLY"
                                                                                                                                                                                                                    	ScheduleFrequencyTypeOnce     ScheduleFrequencyType = "ONCE"
                                                                                                                                                                                                                    )

                                                                                                                                                                                                                      Enum values for ScheduleFrequencyType

                                                                                                                                                                                                                      func (ScheduleFrequencyType) Values

                                                                                                                                                                                                                        Values returns all known values for ScheduleFrequencyType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                        type ScheduledTriggerProperties

                                                                                                                                                                                                                        type ScheduledTriggerProperties struct {
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// The scheduling expression that determines the rate at which the schedule will
                                                                                                                                                                                                                        	// run, for example rate(5minutes).
                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                                                        	ScheduleExpression *string
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// Specifies whether a scheduled flow has an incremental data transfer or a
                                                                                                                                                                                                                        	// complete data transfer for each flow run.
                                                                                                                                                                                                                        	DataPullMode DataPullMode
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// Specifies the scheduled end time for a schedule-triggered flow.
                                                                                                                                                                                                                        	ScheduleEndTime *time.Time
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// Specifies the scheduled start time for a schedule-triggered flow.
                                                                                                                                                                                                                        	ScheduleStartTime *time.Time
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// Specifies the time zone used when referring to the date and time of a
                                                                                                                                                                                                                        	// scheduled-triggered flow.
                                                                                                                                                                                                                        	Timezone *string
                                                                                                                                                                                                                        }

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

                                                                                                                                                                                                                          type ServiceNowConnectorOperator

                                                                                                                                                                                                                          type ServiceNowConnectorOperator string
                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                          	ServiceNowConnectorOperatorProjection           ServiceNowConnectorOperator = "PROJECTION"
                                                                                                                                                                                                                          	ServiceNowConnectorOperatorContains             ServiceNowConnectorOperator = "CONTAINS"
                                                                                                                                                                                                                          	ServiceNowConnectorOperatorLessThan             ServiceNowConnectorOperator = "LESS_THAN"
                                                                                                                                                                                                                          	ServiceNowConnectorOperatorGreaterThan          ServiceNowConnectorOperator = "GREATER_THAN"
                                                                                                                                                                                                                          	ServiceNowConnectorOperatorBetween              ServiceNowConnectorOperator = "BETWEEN"
                                                                                                                                                                                                                          	ServiceNowConnectorOperatorLessThanOrEqualTo    ServiceNowConnectorOperator = "LESS_THAN_OR_EQUAL_TO"
                                                                                                                                                                                                                          	ServiceNowConnectorOperatorGreaterThanOrEqualTo ServiceNowConnectorOperator = "GREATER_THAN_OR_EQUAL_TO"
                                                                                                                                                                                                                          	ServiceNowConnectorOperatorEqualTo              ServiceNowConnectorOperator = "EQUAL_TO"
                                                                                                                                                                                                                          	ServiceNowConnectorOperatorNotEqualTo           ServiceNowConnectorOperator = "NOT_EQUAL_TO"
                                                                                                                                                                                                                          	ServiceNowConnectorOperatorAddition             ServiceNowConnectorOperator = "ADDITION"
                                                                                                                                                                                                                          	ServiceNowConnectorOperatorMultiplication       ServiceNowConnectorOperator = "MULTIPLICATION"
                                                                                                                                                                                                                          	ServiceNowConnectorOperatorDivision             ServiceNowConnectorOperator = "DIVISION"
                                                                                                                                                                                                                          	ServiceNowConnectorOperatorSubtraction          ServiceNowConnectorOperator = "SUBTRACTION"
                                                                                                                                                                                                                          	ServiceNowConnectorOperatorMaskAll              ServiceNowConnectorOperator = "MASK_ALL"
                                                                                                                                                                                                                          	ServiceNowConnectorOperatorMaskFirstN           ServiceNowConnectorOperator = "MASK_FIRST_N"
                                                                                                                                                                                                                          	ServiceNowConnectorOperatorMaskLastN            ServiceNowConnectorOperator = "MASK_LAST_N"
                                                                                                                                                                                                                          	ServiceNowConnectorOperatorValidateNonNull      ServiceNowConnectorOperator = "VALIDATE_NON_NULL"
                                                                                                                                                                                                                          	ServiceNowConnectorOperatorValidateNonZero      ServiceNowConnectorOperator = "VALIDATE_NON_ZERO"
                                                                                                                                                                                                                          	ServiceNowConnectorOperatorValidateNonNegative  ServiceNowConnectorOperator = "VALIDATE_NON_NEGATIVE"
                                                                                                                                                                                                                          	ServiceNowConnectorOperatorValidateNumeric      ServiceNowConnectorOperator = "VALIDATE_NUMERIC"
                                                                                                                                                                                                                          	ServiceNowConnectorOperatorNoOp                 ServiceNowConnectorOperator = "NO_OP"
                                                                                                                                                                                                                          )

                                                                                                                                                                                                                            Enum values for ServiceNowConnectorOperator

                                                                                                                                                                                                                            func (ServiceNowConnectorOperator) Values

                                                                                                                                                                                                                              Values returns all known values for ServiceNowConnectorOperator. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                              type ServiceNowConnectorProfileCredentials

                                                                                                                                                                                                                              type ServiceNowConnectorProfileCredentials struct {
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// The password that corresponds to the user name.
                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                              	Password *string
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// The name of the user.
                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                              	Username *string
                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                The connector-specific profile credentials required when using ServiceNow.

                                                                                                                                                                                                                                type ServiceNowConnectorProfileProperties

                                                                                                                                                                                                                                type ServiceNowConnectorProfileProperties struct {
                                                                                                                                                                                                                                
                                                                                                                                                                                                                                	// The location of the ServiceNow resource.
                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                	InstanceUrl *string
                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                  The connector-specific profile properties required when using ServiceNow.

                                                                                                                                                                                                                                  type ServiceNowMetadata

                                                                                                                                                                                                                                  type ServiceNowMetadata struct {
                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                    The connector metadata specific to ServiceNow.

                                                                                                                                                                                                                                    type ServiceNowSourceProperties

                                                                                                                                                                                                                                    type ServiceNowSourceProperties struct {
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// The object specified in the ServiceNow flow source.
                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                    	Object *string
                                                                                                                                                                                                                                    }

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

                                                                                                                                                                                                                                      type ServiceQuotaExceededException

                                                                                                                                                                                                                                      type ServiceQuotaExceededException struct {
                                                                                                                                                                                                                                      	Message *string
                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                        The request would cause a service quota (such as the number of flows) to be exceeded.

                                                                                                                                                                                                                                        func (*ServiceQuotaExceededException) Error

                                                                                                                                                                                                                                        func (*ServiceQuotaExceededException) ErrorCode

                                                                                                                                                                                                                                        func (e *ServiceQuotaExceededException) ErrorCode() string

                                                                                                                                                                                                                                        func (*ServiceQuotaExceededException) ErrorFault

                                                                                                                                                                                                                                        func (*ServiceQuotaExceededException) ErrorMessage

                                                                                                                                                                                                                                        func (e *ServiceQuotaExceededException) ErrorMessage() string

                                                                                                                                                                                                                                        type SingularConnectorOperator

                                                                                                                                                                                                                                        type SingularConnectorOperator string
                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                        	SingularConnectorOperatorProjection          SingularConnectorOperator = "PROJECTION"
                                                                                                                                                                                                                                        	SingularConnectorOperatorEqualTo             SingularConnectorOperator = "EQUAL_TO"
                                                                                                                                                                                                                                        	SingularConnectorOperatorAddition            SingularConnectorOperator = "ADDITION"
                                                                                                                                                                                                                                        	SingularConnectorOperatorMultiplication      SingularConnectorOperator = "MULTIPLICATION"
                                                                                                                                                                                                                                        	SingularConnectorOperatorDivision            SingularConnectorOperator = "DIVISION"
                                                                                                                                                                                                                                        	SingularConnectorOperatorSubtraction         SingularConnectorOperator = "SUBTRACTION"
                                                                                                                                                                                                                                        	SingularConnectorOperatorMaskAll             SingularConnectorOperator = "MASK_ALL"
                                                                                                                                                                                                                                        	SingularConnectorOperatorMaskFirstN          SingularConnectorOperator = "MASK_FIRST_N"
                                                                                                                                                                                                                                        	SingularConnectorOperatorMaskLastN           SingularConnectorOperator = "MASK_LAST_N"
                                                                                                                                                                                                                                        	SingularConnectorOperatorValidateNonNull     SingularConnectorOperator = "VALIDATE_NON_NULL"
                                                                                                                                                                                                                                        	SingularConnectorOperatorValidateNonZero     SingularConnectorOperator = "VALIDATE_NON_ZERO"
                                                                                                                                                                                                                                        	SingularConnectorOperatorValidateNonNegative SingularConnectorOperator = "VALIDATE_NON_NEGATIVE"
                                                                                                                                                                                                                                        	SingularConnectorOperatorValidateNumeric     SingularConnectorOperator = "VALIDATE_NUMERIC"
                                                                                                                                                                                                                                        	SingularConnectorOperatorNoOp                SingularConnectorOperator = "NO_OP"
                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                          Enum values for SingularConnectorOperator

                                                                                                                                                                                                                                          func (SingularConnectorOperator) Values

                                                                                                                                                                                                                                            Values returns all known values for SingularConnectorOperator. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                            type SingularConnectorProfileCredentials

                                                                                                                                                                                                                                            type SingularConnectorProfileCredentials struct {
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// A unique alphanumeric identifier used to authenticate a user, developer, or
                                                                                                                                                                                                                                            	// calling program to your API.
                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                            	ApiKey *string
                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                              The connector-specific profile credentials required when using Singular.

                                                                                                                                                                                                                                              type SingularConnectorProfileProperties

                                                                                                                                                                                                                                              type SingularConnectorProfileProperties struct {
                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                The connector-specific profile properties required when using Singular.

                                                                                                                                                                                                                                                type SingularMetadata

                                                                                                                                                                                                                                                type SingularMetadata struct {
                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                  The connector metadata specific to Singular.

                                                                                                                                                                                                                                                  type SingularSourceProperties

                                                                                                                                                                                                                                                  type SingularSourceProperties struct {
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// The object specified in the Singular flow source.
                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                  	Object *string
                                                                                                                                                                                                                                                  }

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

                                                                                                                                                                                                                                                    type SlackConnectorOperator

                                                                                                                                                                                                                                                    type SlackConnectorOperator string
                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                    	SlackConnectorOperatorProjection           SlackConnectorOperator = "PROJECTION"
                                                                                                                                                                                                                                                    	SlackConnectorOperatorLessThan             SlackConnectorOperator = "LESS_THAN"
                                                                                                                                                                                                                                                    	SlackConnectorOperatorGreaterThan          SlackConnectorOperator = "GREATER_THAN"
                                                                                                                                                                                                                                                    	SlackConnectorOperatorBetween              SlackConnectorOperator = "BETWEEN"
                                                                                                                                                                                                                                                    	SlackConnectorOperatorLessThanOrEqualTo    SlackConnectorOperator = "LESS_THAN_OR_EQUAL_TO"
                                                                                                                                                                                                                                                    	SlackConnectorOperatorGreaterThanOrEqualTo SlackConnectorOperator = "GREATER_THAN_OR_EQUAL_TO"
                                                                                                                                                                                                                                                    	SlackConnectorOperatorEqualTo              SlackConnectorOperator = "EQUAL_TO"
                                                                                                                                                                                                                                                    	SlackConnectorOperatorAddition             SlackConnectorOperator = "ADDITION"
                                                                                                                                                                                                                                                    	SlackConnectorOperatorMultiplication       SlackConnectorOperator = "MULTIPLICATION"
                                                                                                                                                                                                                                                    	SlackConnectorOperatorDivision             SlackConnectorOperator = "DIVISION"
                                                                                                                                                                                                                                                    	SlackConnectorOperatorSubtraction          SlackConnectorOperator = "SUBTRACTION"
                                                                                                                                                                                                                                                    	SlackConnectorOperatorMaskAll              SlackConnectorOperator = "MASK_ALL"
                                                                                                                                                                                                                                                    	SlackConnectorOperatorMaskFirstN           SlackConnectorOperator = "MASK_FIRST_N"
                                                                                                                                                                                                                                                    	SlackConnectorOperatorMaskLastN            SlackConnectorOperator = "MASK_LAST_N"
                                                                                                                                                                                                                                                    	SlackConnectorOperatorValidateNonNull      SlackConnectorOperator = "VALIDATE_NON_NULL"
                                                                                                                                                                                                                                                    	SlackConnectorOperatorValidateNonZero      SlackConnectorOperator = "VALIDATE_NON_ZERO"
                                                                                                                                                                                                                                                    	SlackConnectorOperatorValidateNonNegative  SlackConnectorOperator = "VALIDATE_NON_NEGATIVE"
                                                                                                                                                                                                                                                    	SlackConnectorOperatorValidateNumeric      SlackConnectorOperator = "VALIDATE_NUMERIC"
                                                                                                                                                                                                                                                    	SlackConnectorOperatorNoOp                 SlackConnectorOperator = "NO_OP"
                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                      Enum values for SlackConnectorOperator

                                                                                                                                                                                                                                                      func (SlackConnectorOperator) Values

                                                                                                                                                                                                                                                        Values returns all known values for SlackConnectorOperator. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                        type SlackConnectorProfileCredentials

                                                                                                                                                                                                                                                        type SlackConnectorProfileCredentials struct {
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	// The identifier for the client.
                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                                                                                        	ClientId *string
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	// The client secret used by the OAuth client to authenticate to the authorization
                                                                                                                                                                                                                                                        	// server.
                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                                                                                        	ClientSecret *string
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	// The credentials used to access protected Slack resources.
                                                                                                                                                                                                                                                        	AccessToken *string
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	// The OAuth requirement needed to request security tokens from the connector
                                                                                                                                                                                                                                                        	// endpoint.
                                                                                                                                                                                                                                                        	OAuthRequest *ConnectorOAuthRequest
                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                          The connector-specific profile credentials required when using Slack.

                                                                                                                                                                                                                                                          type SlackConnectorProfileProperties

                                                                                                                                                                                                                                                          type SlackConnectorProfileProperties struct {
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// The location of the Slack resource.
                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                          	InstanceUrl *string
                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                            The connector-specific profile properties required when using Slack.

                                                                                                                                                                                                                                                            type SlackMetadata

                                                                                                                                                                                                                                                            type SlackMetadata struct {
                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                            	// The desired authorization scope for the Slack account.
                                                                                                                                                                                                                                                            	OAuthScopes []string
                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                              The connector metadata specific to Slack.

                                                                                                                                                                                                                                                              type SlackSourceProperties

                                                                                                                                                                                                                                                              type SlackSourceProperties struct {
                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                              	// The object specified in the Slack flow source.
                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                              	Object *string
                                                                                                                                                                                                                                                              }

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

                                                                                                                                                                                                                                                                type SnowflakeConnectorProfileCredentials

                                                                                                                                                                                                                                                                type SnowflakeConnectorProfileCredentials struct {
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The password that corresponds to the user name.
                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                	Password *string
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The name of the user.
                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                	Username *string
                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                  The connector-specific profile credentials required when using Snowflake.

                                                                                                                                                                                                                                                                  type SnowflakeConnectorProfileProperties

                                                                                                                                                                                                                                                                  type SnowflakeConnectorProfileProperties struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The name of the Amazon S3 bucket associated with Snowflake.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	BucketName *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The name of the Amazon S3 stage that was created while setting up an Amazon S3
                                                                                                                                                                                                                                                                  	// stage in the Snowflake account. This is written in the following format: <
                                                                                                                                                                                                                                                                  	// Database>< Schema>.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	Stage *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The name of the Snowflake warehouse.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	Warehouse *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The name of the account.
                                                                                                                                                                                                                                                                  	AccountName *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The bucket path that refers to the Amazon S3 bucket associated with Snowflake.
                                                                                                                                                                                                                                                                  	BucketPrefix *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The Snowflake Private Link service name to be used for private data transfers.
                                                                                                                                                                                                                                                                  	PrivateLinkServiceName *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The AWS Region of the Snowflake account.
                                                                                                                                                                                                                                                                  	Region *string
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                    The connector-specific profile properties required when using Snowflake.

                                                                                                                                                                                                                                                                    type SnowflakeDestinationProperties

                                                                                                                                                                                                                                                                    type SnowflakeDestinationProperties struct {
                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                    	// The intermediate bucket that Amazon AppFlow uses when moving data into
                                                                                                                                                                                                                                                                    	// Snowflake.
                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                    	IntermediateBucketName *string
                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                    	// The object specified in the Snowflake flow destination.
                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                    	Object *string
                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                    	// The object key for the destination bucket in which Amazon AppFlow places the
                                                                                                                                                                                                                                                                    	// files.
                                                                                                                                                                                                                                                                    	BucketPrefix *string
                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                    	// The settings that determine how Amazon AppFlow handles an error when placing
                                                                                                                                                                                                                                                                    	// data in the Snowflake 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.
                                                                                                                                                                                                                                                                    	ErrorHandlingConfig *ErrorHandlingConfig
                                                                                                                                                                                                                                                                    }

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

                                                                                                                                                                                                                                                                      type SnowflakeMetadata

                                                                                                                                                                                                                                                                      type SnowflakeMetadata struct {
                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                      	// Specifies the supported AWS Regions when using Snowflake.
                                                                                                                                                                                                                                                                      	SupportedRegions []string
                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                        The connector metadata specific to Snowflake.

                                                                                                                                                                                                                                                                        type SourceConnectorProperties

                                                                                                                                                                                                                                                                        type SourceConnectorProperties struct {
                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                        	// Specifies the information that is required for querying Amplitude.
                                                                                                                                                                                                                                                                        	Amplitude *AmplitudeSourceProperties
                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                        	// Specifies the information that is required for querying Datadog.
                                                                                                                                                                                                                                                                        	Datadog *DatadogSourceProperties
                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                        	// Specifies the information that is required for querying Dynatrace.
                                                                                                                                                                                                                                                                        	Dynatrace *DynatraceSourceProperties
                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                        	// Specifies the information that is required for querying Google Analytics.
                                                                                                                                                                                                                                                                        	GoogleAnalytics *GoogleAnalyticsSourceProperties
                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                        	// Specifies the information that is required for querying Infor Nexus.
                                                                                                                                                                                                                                                                        	InforNexus *InforNexusSourceProperties
                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                        	// Specifies the information that is required for querying Marketo.
                                                                                                                                                                                                                                                                        	Marketo *MarketoSourceProperties
                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                        	// Specifies the information that is required for querying Amazon S3.
                                                                                                                                                                                                                                                                        	S3 *S3SourceProperties
                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                        	// Specifies the information that is required for querying Salesforce.
                                                                                                                                                                                                                                                                        	Salesforce *SalesforceSourceProperties
                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                        	// Specifies the information that is required for querying ServiceNow.
                                                                                                                                                                                                                                                                        	ServiceNow *ServiceNowSourceProperties
                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                        	// Specifies the information that is required for querying Singular.
                                                                                                                                                                                                                                                                        	Singular *SingularSourceProperties
                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                        	// Specifies the information that is required for querying Slack.
                                                                                                                                                                                                                                                                        	Slack *SlackSourceProperties
                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                        	// Specifies the information that is required for querying Trend Micro.
                                                                                                                                                                                                                                                                        	Trendmicro *TrendmicroSourceProperties
                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                        	// Specifies the information that is required for querying Veeva.
                                                                                                                                                                                                                                                                        	Veeva *VeevaSourceProperties
                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                        	// Specifies the information that is required for querying Zendesk.
                                                                                                                                                                                                                                                                        	Zendesk *ZendeskSourceProperties
                                                                                                                                                                                                                                                                        }

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

                                                                                                                                                                                                                                                                          type SourceFieldProperties

                                                                                                                                                                                                                                                                          type SourceFieldProperties struct {
                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                          	// Indicates if the field can be queried.
                                                                                                                                                                                                                                                                          	IsQueryable bool
                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                          	// Indicates whether the field can be returned in a search result.
                                                                                                                                                                                                                                                                          	IsRetrievable bool
                                                                                                                                                                                                                                                                          }

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

                                                                                                                                                                                                                                                                            type SourceFlowConfig

                                                                                                                                                                                                                                                                            type SourceFlowConfig struct {
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// The type of connector, such as Salesforce, Amplitude, and so on.
                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                            	ConnectorType ConnectorType
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// Specifies the information that is required to query a particular source
                                                                                                                                                                                                                                                                            	// connector.
                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                            	SourceConnectorProperties *SourceConnectorProperties
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// The name of the connector profile. This name must be unique for each connector
                                                                                                                                                                                                                                                                            	// profile in the AWS account.
                                                                                                                                                                                                                                                                            	ConnectorProfileName *string
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// Defines the configuration for a scheduled incremental data pull. If a valid
                                                                                                                                                                                                                                                                            	// configuration is provided, the fields specified in the configuration are used
                                                                                                                                                                                                                                                                            	// when querying for the incremental data pull.
                                                                                                                                                                                                                                                                            	IncrementalPullConfig *IncrementalPullConfig
                                                                                                                                                                                                                                                                            }

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

                                                                                                                                                                                                                                                                              type SupportedFieldTypeDetails

                                                                                                                                                                                                                                                                              type SupportedFieldTypeDetails struct {
                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                              	// The initial supported version for fieldType. If this is later changed to a
                                                                                                                                                                                                                                                                              	// different version, v2 will be introduced.
                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                              	V1 *FieldTypeDetails
                                                                                                                                                                                                                                                                              }

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

                                                                                                                                                                                                                                                                                type Task

                                                                                                                                                                                                                                                                                type Task struct {
                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                	// The source fields to which a particular task is applied.
                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                                	SourceFields []string
                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                	// Specifies the particular task implementation that Amazon AppFlow performs.
                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                                	TaskType TaskType
                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                	// The operation to be performed on the provided source fields.
                                                                                                                                                                                                                                                                                	ConnectorOperator *ConnectorOperator
                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                	// A field in a destination connector, or a field value against which Amazon
                                                                                                                                                                                                                                                                                	// AppFlow validates a source field.
                                                                                                                                                                                                                                                                                	DestinationField *string
                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                	// A map used to store task-related information. The execution service looks for
                                                                                                                                                                                                                                                                                	// particular information based on the TaskType.
                                                                                                                                                                                                                                                                                	TaskProperties map[string]string
                                                                                                                                                                                                                                                                                }

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

                                                                                                                                                                                                                                                                                  type TaskType

                                                                                                                                                                                                                                                                                  type TaskType string
                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                  	TaskTypeArithmetic TaskType = "Arithmetic"
                                                                                                                                                                                                                                                                                  	TaskTypeFilter     TaskType = "Filter"
                                                                                                                                                                                                                                                                                  	TaskTypeMap        TaskType = "Map"
                                                                                                                                                                                                                                                                                  	TaskTypeMask       TaskType = "Mask"
                                                                                                                                                                                                                                                                                  	TaskTypeMerge      TaskType = "Merge"
                                                                                                                                                                                                                                                                                  	TaskTypeTruncate   TaskType = "Truncate"
                                                                                                                                                                                                                                                                                  	TaskTypeValidate   TaskType = "Validate"
                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                    Enum values for TaskType

                                                                                                                                                                                                                                                                                    func (TaskType) Values

                                                                                                                                                                                                                                                                                    func (TaskType) Values() []TaskType

                                                                                                                                                                                                                                                                                      Values returns all known values for TaskType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                      type TrendmicroConnectorOperator

                                                                                                                                                                                                                                                                                      type TrendmicroConnectorOperator string
                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                      	TrendmicroConnectorOperatorProjection          TrendmicroConnectorOperator = "PROJECTION"
                                                                                                                                                                                                                                                                                      	TrendmicroConnectorOperatorEqualTo             TrendmicroConnectorOperator = "EQUAL_TO"
                                                                                                                                                                                                                                                                                      	TrendmicroConnectorOperatorAddition            TrendmicroConnectorOperator = "ADDITION"
                                                                                                                                                                                                                                                                                      	TrendmicroConnectorOperatorMultiplication      TrendmicroConnectorOperator = "MULTIPLICATION"
                                                                                                                                                                                                                                                                                      	TrendmicroConnectorOperatorDivision            TrendmicroConnectorOperator = "DIVISION"
                                                                                                                                                                                                                                                                                      	TrendmicroConnectorOperatorSubtraction         TrendmicroConnectorOperator = "SUBTRACTION"
                                                                                                                                                                                                                                                                                      	TrendmicroConnectorOperatorMaskAll             TrendmicroConnectorOperator = "MASK_ALL"
                                                                                                                                                                                                                                                                                      	TrendmicroConnectorOperatorMaskFirstN          TrendmicroConnectorOperator = "MASK_FIRST_N"
                                                                                                                                                                                                                                                                                      	TrendmicroConnectorOperatorMaskLastN           TrendmicroConnectorOperator = "MASK_LAST_N"
                                                                                                                                                                                                                                                                                      	TrendmicroConnectorOperatorValidateNonNull     TrendmicroConnectorOperator = "VALIDATE_NON_NULL"
                                                                                                                                                                                                                                                                                      	TrendmicroConnectorOperatorValidateNonZero     TrendmicroConnectorOperator = "VALIDATE_NON_ZERO"
                                                                                                                                                                                                                                                                                      	TrendmicroConnectorOperatorValidateNonNegative TrendmicroConnectorOperator = "VALIDATE_NON_NEGATIVE"
                                                                                                                                                                                                                                                                                      	TrendmicroConnectorOperatorValidateNumeric     TrendmicroConnectorOperator = "VALIDATE_NUMERIC"
                                                                                                                                                                                                                                                                                      	TrendmicroConnectorOperatorNoOp                TrendmicroConnectorOperator = "NO_OP"
                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                        Enum values for TrendmicroConnectorOperator

                                                                                                                                                                                                                                                                                        func (TrendmicroConnectorOperator) Values

                                                                                                                                                                                                                                                                                          Values returns all known values for TrendmicroConnectorOperator. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                          type TrendmicroConnectorProfileCredentials

                                                                                                                                                                                                                                                                                          type TrendmicroConnectorProfileCredentials struct {
                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                          	// The Secret Access Key portion of the credentials.
                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                          	ApiSecretKey *string
                                                                                                                                                                                                                                                                                          }

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

                                                                                                                                                                                                                                                                                            type TrendmicroConnectorProfileProperties

                                                                                                                                                                                                                                                                                            type TrendmicroConnectorProfileProperties struct {
                                                                                                                                                                                                                                                                                            }

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

                                                                                                                                                                                                                                                                                              type TrendmicroMetadata

                                                                                                                                                                                                                                                                                              type TrendmicroMetadata struct {
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                The connector metadata specific to Trend Micro.

                                                                                                                                                                                                                                                                                                type TrendmicroSourceProperties

                                                                                                                                                                                                                                                                                                type TrendmicroSourceProperties struct {
                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                	// The object specified in the Trend Micro flow source.
                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                                                	Object *string
                                                                                                                                                                                                                                                                                                }

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

                                                                                                                                                                                                                                                                                                  type TriggerConfig

                                                                                                                                                                                                                                                                                                  type TriggerConfig struct {
                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                  	// Specifies the type of flow trigger. This can be OnDemand, Scheduled, or Event.
                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                  	TriggerType TriggerType
                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                  	// Specifies the configuration details of a schedule-triggered flow as defined by
                                                                                                                                                                                                                                                                                                  	// the user. Currently, these settings only apply to the Scheduled trigger type.
                                                                                                                                                                                                                                                                                                  	TriggerProperties *TriggerProperties
                                                                                                                                                                                                                                                                                                  }

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

                                                                                                                                                                                                                                                                                                    type TriggerProperties

                                                                                                                                                                                                                                                                                                    type TriggerProperties struct {
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// Specifies the configuration details of a schedule-triggered flow as defined by
                                                                                                                                                                                                                                                                                                    	// the user.
                                                                                                                                                                                                                                                                                                    	Scheduled *ScheduledTriggerProperties
                                                                                                                                                                                                                                                                                                    }

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

                                                                                                                                                                                                                                                                                                      type TriggerType

                                                                                                                                                                                                                                                                                                      type TriggerType string
                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                      	TriggerTypeScheduled TriggerType = "Scheduled"
                                                                                                                                                                                                                                                                                                      	TriggerTypeEvent     TriggerType = "Event"
                                                                                                                                                                                                                                                                                                      	TriggerTypeOndemand  TriggerType = "OnDemand"
                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                        Enum values for TriggerType

                                                                                                                                                                                                                                                                                                        func (TriggerType) Values

                                                                                                                                                                                                                                                                                                        func (TriggerType) Values() []TriggerType

                                                                                                                                                                                                                                                                                                          Values returns all known values for TriggerType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                          type UnsupportedOperationException

                                                                                                                                                                                                                                                                                                          type UnsupportedOperationException struct {
                                                                                                                                                                                                                                                                                                          	Message *string
                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                            The requested operation is not supported for the current flow.

                                                                                                                                                                                                                                                                                                            func (*UnsupportedOperationException) Error

                                                                                                                                                                                                                                                                                                            func (*UnsupportedOperationException) ErrorCode

                                                                                                                                                                                                                                                                                                            func (e *UnsupportedOperationException) ErrorCode() string

                                                                                                                                                                                                                                                                                                            func (*UnsupportedOperationException) ErrorFault

                                                                                                                                                                                                                                                                                                            func (*UnsupportedOperationException) ErrorMessage

                                                                                                                                                                                                                                                                                                            func (e *UnsupportedOperationException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                            type UpsolverDestinationProperties

                                                                                                                                                                                                                                                                                                            type UpsolverDestinationProperties struct {
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// The Upsolver Amazon S3 bucket name in which Amazon AppFlow places the
                                                                                                                                                                                                                                                                                                            	// transferred data.
                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                                            	BucketName *string
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// The configuration that determines how data is formatted when Upsolver is used as
                                                                                                                                                                                                                                                                                                            	// the flow destination.
                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                                            	S3OutputFormatConfig *UpsolverS3OutputFormatConfig
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// The object key for the destination Upsolver Amazon S3 bucket in which Amazon
                                                                                                                                                                                                                                                                                                            	// AppFlow places the files.
                                                                                                                                                                                                                                                                                                            	BucketPrefix *string
                                                                                                                                                                                                                                                                                                            }

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

                                                                                                                                                                                                                                                                                                              type UpsolverMetadata

                                                                                                                                                                                                                                                                                                              type UpsolverMetadata struct {
                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                The connector metadata specific to Upsolver.

                                                                                                                                                                                                                                                                                                                type UpsolverS3OutputFormatConfig

                                                                                                                                                                                                                                                                                                                type UpsolverS3OutputFormatConfig struct {
                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                	// Determines the prefix that Amazon AppFlow applies to the destination folder
                                                                                                                                                                                                                                                                                                                	// name. You can name your destination folders according to the flow frequency and
                                                                                                                                                                                                                                                                                                                	// date.
                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                                                                	PrefixConfig *PrefixConfig
                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                	// The aggregation settings that you can use to customize the output format of your
                                                                                                                                                                                                                                                                                                                	// flow data.
                                                                                                                                                                                                                                                                                                                	AggregationConfig *AggregationConfig
                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                	// Indicates the file type that Amazon AppFlow places in the Upsolver Amazon S3
                                                                                                                                                                                                                                                                                                                	// bucket.
                                                                                                                                                                                                                                                                                                                	FileType FileType
                                                                                                                                                                                                                                                                                                                }

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

                                                                                                                                                                                                                                                                                                                  type ValidationException

                                                                                                                                                                                                                                                                                                                  type ValidationException struct {
                                                                                                                                                                                                                                                                                                                  	Message *string
                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                    The request has invalid or missing parameters.

                                                                                                                                                                                                                                                                                                                    func (*ValidationException) Error

                                                                                                                                                                                                                                                                                                                    func (e *ValidationException) Error() string

                                                                                                                                                                                                                                                                                                                    func (*ValidationException) ErrorCode

                                                                                                                                                                                                                                                                                                                    func (e *ValidationException) ErrorCode() string

                                                                                                                                                                                                                                                                                                                    func (*ValidationException) ErrorFault

                                                                                                                                                                                                                                                                                                                    func (e *ValidationException) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                                                                                    func (*ValidationException) ErrorMessage

                                                                                                                                                                                                                                                                                                                    func (e *ValidationException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                    type VeevaConnectorOperator

                                                                                                                                                                                                                                                                                                                    type VeevaConnectorOperator string
                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                    	VeevaConnectorOperatorProjection           VeevaConnectorOperator = "PROJECTION"
                                                                                                                                                                                                                                                                                                                    	VeevaConnectorOperatorLessThan             VeevaConnectorOperator = "LESS_THAN"
                                                                                                                                                                                                                                                                                                                    	VeevaConnectorOperatorGreaterThan          VeevaConnectorOperator = "GREATER_THAN"
                                                                                                                                                                                                                                                                                                                    	VeevaConnectorOperatorContains             VeevaConnectorOperator = "CONTAINS"
                                                                                                                                                                                                                                                                                                                    	VeevaConnectorOperatorBetween              VeevaConnectorOperator = "BETWEEN"
                                                                                                                                                                                                                                                                                                                    	VeevaConnectorOperatorLessThanOrEqualTo    VeevaConnectorOperator = "LESS_THAN_OR_EQUAL_TO"
                                                                                                                                                                                                                                                                                                                    	VeevaConnectorOperatorGreaterThanOrEqualTo VeevaConnectorOperator = "GREATER_THAN_OR_EQUAL_TO"
                                                                                                                                                                                                                                                                                                                    	VeevaConnectorOperatorEqualTo              VeevaConnectorOperator = "EQUAL_TO"
                                                                                                                                                                                                                                                                                                                    	VeevaConnectorOperatorNotEqualTo           VeevaConnectorOperator = "NOT_EQUAL_TO"
                                                                                                                                                                                                                                                                                                                    	VeevaConnectorOperatorAddition             VeevaConnectorOperator = "ADDITION"
                                                                                                                                                                                                                                                                                                                    	VeevaConnectorOperatorMultiplication       VeevaConnectorOperator = "MULTIPLICATION"
                                                                                                                                                                                                                                                                                                                    	VeevaConnectorOperatorDivision             VeevaConnectorOperator = "DIVISION"
                                                                                                                                                                                                                                                                                                                    	VeevaConnectorOperatorSubtraction          VeevaConnectorOperator = "SUBTRACTION"
                                                                                                                                                                                                                                                                                                                    	VeevaConnectorOperatorMaskAll              VeevaConnectorOperator = "MASK_ALL"
                                                                                                                                                                                                                                                                                                                    	VeevaConnectorOperatorMaskFirstN           VeevaConnectorOperator = "MASK_FIRST_N"
                                                                                                                                                                                                                                                                                                                    	VeevaConnectorOperatorMaskLastN            VeevaConnectorOperator = "MASK_LAST_N"
                                                                                                                                                                                                                                                                                                                    	VeevaConnectorOperatorValidateNonNull      VeevaConnectorOperator = "VALIDATE_NON_NULL"
                                                                                                                                                                                                                                                                                                                    	VeevaConnectorOperatorValidateNonZero      VeevaConnectorOperator = "VALIDATE_NON_ZERO"
                                                                                                                                                                                                                                                                                                                    	VeevaConnectorOperatorValidateNonNegative  VeevaConnectorOperator = "VALIDATE_NON_NEGATIVE"
                                                                                                                                                                                                                                                                                                                    	VeevaConnectorOperatorValidateNumeric      VeevaConnectorOperator = "VALIDATE_NUMERIC"
                                                                                                                                                                                                                                                                                                                    	VeevaConnectorOperatorNoOp                 VeevaConnectorOperator = "NO_OP"
                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                      Enum values for VeevaConnectorOperator

                                                                                                                                                                                                                                                                                                                      func (VeevaConnectorOperator) Values

                                                                                                                                                                                                                                                                                                                        Values returns all known values for VeevaConnectorOperator. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                        type VeevaConnectorProfileCredentials

                                                                                                                                                                                                                                                                                                                        type VeevaConnectorProfileCredentials struct {
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The password that corresponds to the user name.
                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                                                                                                                                                        	Password *string
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The name of the user.
                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                                                                                                                                                        	Username *string
                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                          The connector-specific profile credentials required when using Veeva.

                                                                                                                                                                                                                                                                                                                          type VeevaConnectorProfileProperties

                                                                                                                                                                                                                                                                                                                          type VeevaConnectorProfileProperties struct {
                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                          	// The location of the Veeva resource.
                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                          	InstanceUrl *string
                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                            The connector-specific profile properties required when using Veeva.

                                                                                                                                                                                                                                                                                                                            type VeevaMetadata

                                                                                                                                                                                                                                                                                                                            type VeevaMetadata struct {
                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                              The connector metadata specific to Veeva.

                                                                                                                                                                                                                                                                                                                              type VeevaSourceProperties

                                                                                                                                                                                                                                                                                                                              type VeevaSourceProperties struct {
                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                              	// The object specified in the Veeva flow source.
                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                                                                              	Object *string
                                                                                                                                                                                                                                                                                                                              }

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

                                                                                                                                                                                                                                                                                                                                type WriteOperationType

                                                                                                                                                                                                                                                                                                                                type WriteOperationType string
                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                	WriteOperationTypeInsert WriteOperationType = "INSERT"
                                                                                                                                                                                                                                                                                                                                	WriteOperationTypeUpsert WriteOperationType = "UPSERT"
                                                                                                                                                                                                                                                                                                                                	WriteOperationTypeUpdate WriteOperationType = "UPDATE"
                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                  Enum values for WriteOperationType

                                                                                                                                                                                                                                                                                                                                  func (WriteOperationType) Values

                                                                                                                                                                                                                                                                                                                                    Values returns all known values for WriteOperationType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                    type ZendeskConnectorOperator

                                                                                                                                                                                                                                                                                                                                    type ZendeskConnectorOperator string
                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                    	ZendeskConnectorOperatorProjection          ZendeskConnectorOperator = "PROJECTION"
                                                                                                                                                                                                                                                                                                                                    	ZendeskConnectorOperatorGreaterThan         ZendeskConnectorOperator = "GREATER_THAN"
                                                                                                                                                                                                                                                                                                                                    	ZendeskConnectorOperatorAddition            ZendeskConnectorOperator = "ADDITION"
                                                                                                                                                                                                                                                                                                                                    	ZendeskConnectorOperatorMultiplication      ZendeskConnectorOperator = "MULTIPLICATION"
                                                                                                                                                                                                                                                                                                                                    	ZendeskConnectorOperatorDivision            ZendeskConnectorOperator = "DIVISION"
                                                                                                                                                                                                                                                                                                                                    	ZendeskConnectorOperatorSubtraction         ZendeskConnectorOperator = "SUBTRACTION"
                                                                                                                                                                                                                                                                                                                                    	ZendeskConnectorOperatorMaskAll             ZendeskConnectorOperator = "MASK_ALL"
                                                                                                                                                                                                                                                                                                                                    	ZendeskConnectorOperatorMaskFirstN          ZendeskConnectorOperator = "MASK_FIRST_N"
                                                                                                                                                                                                                                                                                                                                    	ZendeskConnectorOperatorMaskLastN           ZendeskConnectorOperator = "MASK_LAST_N"
                                                                                                                                                                                                                                                                                                                                    	ZendeskConnectorOperatorValidateNonNull     ZendeskConnectorOperator = "VALIDATE_NON_NULL"
                                                                                                                                                                                                                                                                                                                                    	ZendeskConnectorOperatorValidateNonZero     ZendeskConnectorOperator = "VALIDATE_NON_ZERO"
                                                                                                                                                                                                                                                                                                                                    	ZendeskConnectorOperatorValidateNonNegative ZendeskConnectorOperator = "VALIDATE_NON_NEGATIVE"
                                                                                                                                                                                                                                                                                                                                    	ZendeskConnectorOperatorValidateNumeric     ZendeskConnectorOperator = "VALIDATE_NUMERIC"
                                                                                                                                                                                                                                                                                                                                    	ZendeskConnectorOperatorNoOp                ZendeskConnectorOperator = "NO_OP"
                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                      Enum values for ZendeskConnectorOperator

                                                                                                                                                                                                                                                                                                                                      func (ZendeskConnectorOperator) Values

                                                                                                                                                                                                                                                                                                                                        Values returns all known values for ZendeskConnectorOperator. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                        type ZendeskConnectorProfileCredentials

                                                                                                                                                                                                                                                                                                                                        type ZendeskConnectorProfileCredentials struct {
                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                        	// The identifier for the desired client.
                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                                                                                                                                                                        	ClientId *string
                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                        	// The client secret used by the OAuth client to authenticate to the authorization
                                                                                                                                                                                                                                                                                                                                        	// server.
                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                                                                                                                                                                        	ClientSecret *string
                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                        	// The credentials used to access protected Zendesk resources.
                                                                                                                                                                                                                                                                                                                                        	AccessToken *string
                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                        	// The OAuth requirement needed to request security tokens from the connector
                                                                                                                                                                                                                                                                                                                                        	// endpoint.
                                                                                                                                                                                                                                                                                                                                        	OAuthRequest *ConnectorOAuthRequest
                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                          The connector-specific profile credentials required when using Zendesk.

                                                                                                                                                                                                                                                                                                                                          type ZendeskConnectorProfileProperties

                                                                                                                                                                                                                                                                                                                                          type ZendeskConnectorProfileProperties struct {
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The location of the Zendesk resource.
                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                                          	InstanceUrl *string
                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                            The connector-specific profile properties required when using Zendesk.

                                                                                                                                                                                                                                                                                                                                            type ZendeskMetadata

                                                                                                                                                                                                                                                                                                                                            type ZendeskMetadata struct {
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// The desired authorization scope for the Zendesk account.
                                                                                                                                                                                                                                                                                                                                            	OAuthScopes []string
                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                              The connector metadata specific to Zendesk.

                                                                                                                                                                                                                                                                                                                                              type ZendeskSourceProperties

                                                                                                                                                                                                                                                                                                                                              type ZendeskSourceProperties struct {
                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                              	// The object specified in the Zendesk flow source.
                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                                                                                              	Object *string
                                                                                                                                                                                                                                                                                                                                              }

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