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 Amazon Connect Customer Profiles.
                                  	CustomerProfiles *CustomerProfilesMetadata
                                  
                                  	// 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 Amazon Honeycode.
                                  	Honeycode *HoneycodeMetadata
                                  
                                  	// 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 Amazon Honeycode.
                                            	Honeycode *HoneycodeConnectorProfileCredentials
                                            
                                            	// 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 Amazon Honeycode.
                                              	Honeycode *HoneycodeConnectorProfileProperties
                                              
                                              	// 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"
                                                  	ConnectorTypeLookoutmetrics   ConnectorType = "LookoutMetrics"
                                                  	ConnectorTypeUpsolver         ConnectorType = "Upsolver"
                                                  	ConnectorTypeHoneycode        ConnectorType = "Honeycode"
                                                  	ConnectorTypeCustomerprofiles ConnectorType = "CustomerProfiles"
                                                  )

                                                    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 CustomerProfilesDestinationProperties

                                                      type CustomerProfilesDestinationProperties struct {
                                                      
                                                      	// The unique name of the Amazon Connect Customer Profiles domain.
                                                      	//
                                                      	// This member is required.
                                                      	DomainName *string
                                                      
                                                      	// The object specified in the Amazon Connect Customer Profiles flow destination.
                                                      	ObjectTypeName *string
                                                      }

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

                                                        type CustomerProfilesMetadata

                                                        type CustomerProfilesMetadata struct {
                                                        }

                                                          The connector metadata specific to Amazon Connect Customer Profiles.

                                                          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 Connect Customer Profiles.
                                                                          	CustomerProfiles *CustomerProfilesDestinationProperties
                                                                          
                                                                          	// The properties required to query Amazon EventBridge.
                                                                          	EventBridge *EventBridgeDestinationProperties
                                                                          
                                                                          	// The properties required to query Amazon Honeycode.
                                                                          	Honeycode *HoneycodeDestinationProperties
                                                                          
                                                                          	// The properties required to query Amazon Lookout for Metrics.
                                                                          	LookoutMetrics *LookoutMetricsDestinationProperties
                                                                          
                                                                          	// 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 {
                                                                                                      
                                                                                                      	// The timestamp that indicates the last new or updated record to be transferred in
                                                                                                      	// the flow run.
                                                                                                      	DataPullEndTime *time.Time
                                                                                                      
                                                                                                      	// The timestamp that determines the first new or updated record to be transferred
                                                                                                      	// in the flow run.
                                                                                                      	DataPullStartTime *time.Time
                                                                                                      
                                                                                                      	// 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 HoneycodeConnectorProfileCredentials

                                                                                                                                      type HoneycodeConnectorProfileCredentials struct {
                                                                                                                                      
                                                                                                                                      	// The credentials used to access protected Amazon Honeycode resources.
                                                                                                                                      	AccessToken *string
                                                                                                                                      
                                                                                                                                      	// Used by select connectors for which the OAuth workflow is supported, such as
                                                                                                                                      	// Salesforce, Google Analytics, Marketo, Zendesk, and Slack.
                                                                                                                                      	OAuthRequest *ConnectorOAuthRequest
                                                                                                                                      
                                                                                                                                      	// The credentials used to acquire new access tokens.
                                                                                                                                      	RefreshToken *string
                                                                                                                                      }

                                                                                                                                        The connector-specific credentials required when using Amazon Honeycode.

                                                                                                                                        type HoneycodeConnectorProfileProperties

                                                                                                                                        type HoneycodeConnectorProfileProperties struct {
                                                                                                                                        }

                                                                                                                                          The connector-specific properties required when using Amazon Honeycode.

                                                                                                                                          type HoneycodeDestinationProperties

                                                                                                                                          type HoneycodeDestinationProperties struct {
                                                                                                                                          
                                                                                                                                          	// The object specified in the Amazon Honeycode 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 Honeycode is used as a destination.

                                                                                                                                            type HoneycodeMetadata

                                                                                                                                            type HoneycodeMetadata struct {
                                                                                                                                            
                                                                                                                                            	// The desired authorization scope for the Amazon Honeycode account.
                                                                                                                                            	OAuthScopes []string
                                                                                                                                            }

                                                                                                                                              The connector metadata specific to Amazon Honeycode.

                                                                                                                                              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 LookoutMetricsDestinationProperties

                                                                                                                                                              type LookoutMetricsDestinationProperties struct {
                                                                                                                                                              }

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

                                                                                                                                                                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 level of granularity that's included in the prefix.
                                                                                                                                                                                    	PrefixFormat PrefixFormat
                                                                                                                                                                                    
                                                                                                                                                                                    	// Determines the format of the prefix, and whether it applies to the file name,
                                                                                                                                                                                    	// file path, or both.
                                                                                                                                                                                    	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 date range for the records to import from the connector in the
                                                                                                                                                                                                                                      	// first flow run.
                                                                                                                                                                                                                                      	FirstExecutionFrom *time.Time
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// Specifies the scheduled end time for a schedule-triggered flow.
                                                                                                                                                                                                                                      	ScheduleEndTime *time.Time
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// Specifies the optional offset that is added to the time interval for a
                                                                                                                                                                                                                                      	// schedule-triggered flow.
                                                                                                                                                                                                                                      	ScheduleOffset int64
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// 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, such as America/New_York.
                                                                                                                                                                                                                                      	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.