types

package
v0.0.0-...-68f2935 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 24, 2024 License: Apache-2.0 Imports: 4 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccessDeniedException 

type AccessDeniedException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

AppFlow/Requester has invalid or missing permissions.

func (*AccessDeniedException) Error 

func (e *AccessDeniedException) Error() string

func (*AccessDeniedException) ErrorCode 

func (e *AccessDeniedException) ErrorCode() string

func (*AccessDeniedException) ErrorFault 

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

func (*AccessDeniedException) ErrorMessage 

func (e *AccessDeniedException) ErrorMessage() string

type AggregationConfig 

type AggregationConfig struct {

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

	// The desired file size, in MB, for each output file that Amazon AppFlow writes
	// to the flow destination. For each file, Amazon AppFlow attempts to achieve the
	// size that you specify. The actual file sizes might differ from this target based
	// on the number and size of the records that each file contains.
	TargetFileSize *int64
	// contains filtered or unexported fields
}
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 

func (AmplitudeConnectorOperator) Values() []AmplitudeConnectorOperator

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
	// contains filtered or unexported fields
}

The connector-specific credentials required when using Amplitude.

type AmplitudeConnectorProfileProperties 

type AmplitudeConnectorProfileProperties struct {
	// contains filtered or unexported fields
}

The connector-specific profile properties required when using Amplitude.

type AmplitudeMetadata 

type AmplitudeMetadata struct {
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

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

type ApiKeyCredentials 

type ApiKeyCredentials struct {

	// The API key required for API key authentication.
	//
	// This member is required.
	ApiKey *string

	// The API secret key required for API key authentication.
	ApiSecretKey *string
	// contains filtered or unexported fields
}

The API key credentials required for API key authentication.

type AuthParameter 

type AuthParameter struct {

	// Contains default values for this authentication parameter that are supplied by
	// the connector.
	ConnectorSuppliedValues []string

	// A description about the authentication parameter.
	Description *string

	// Indicates whether this authentication parameter is required.
	IsRequired bool

	// Indicates whether this authentication parameter is a sensitive field.
	IsSensitiveField bool

	// The authentication key required to authenticate with the connector.
	Key *string

	// Label used for authentication parameter.
	Label *string
	// contains filtered or unexported fields
}

Information about required authentication parameters.

type AuthenticationConfig 

type AuthenticationConfig struct {

	// Contains information required for custom authentication.
	CustomAuthConfigs []CustomAuthConfig

	// Indicates whether API key authentication is supported by the connector
	IsApiKeyAuthSupported bool

	// Indicates whether basic authentication is supported by the connector.
	IsBasicAuthSupported bool

	// Indicates whether custom authentication is supported by the connector
	IsCustomAuthSupported bool

	// Indicates whether OAuth 2.0 authentication is supported by the connector.
	IsOAuth2Supported bool

	// Contains the default values required for OAuth 2.0 authentication.
	OAuth2Defaults *OAuth2Defaults
	// contains filtered or unexported fields
}

Contains information about the authentication config that the connector supports.

type AuthenticationType 

type AuthenticationType string
const (
	AuthenticationTypeOauth2 AuthenticationType = "OAUTH2"
	AuthenticationTypeApikey AuthenticationType = "APIKEY"
	AuthenticationTypeBasic  AuthenticationType = "BASIC"
	AuthenticationTypeCustom AuthenticationType = "CUSTOM"
)

Enum values for AuthenticationType

func (AuthenticationType) Values 

func (AuthenticationType) Values() []AuthenticationType

Values returns all known values for AuthenticationType. 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 BasicAuthCredentials 

type BasicAuthCredentials struct {

	//  The password to use to connect to a resource.
	//
	// This member is required.
	Password *string

	//  The username to use to connect to a resource.
	//
	// This member is required.
	Username *string
	// contains filtered or unexported fields
}

The basic auth credentials required for basic authentication.

type CatalogType 

type CatalogType string
const (
	CatalogTypeGlue CatalogType = "GLUE"
)

Enum values for CatalogType

func (CatalogType) Values 

func (CatalogType) Values() []CatalogType

Values returns all known values for CatalogType. 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 ConflictException 

type ConflictException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}
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

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

An error occurred when authenticating with the connector endpoint.

func (*ConnectorAuthenticationException) Error 

func (e *ConnectorAuthenticationException) Error() string

func (*ConnectorAuthenticationException) ErrorCode 

func (e *ConnectorAuthenticationException) ErrorCode() string

func (*ConnectorAuthenticationException) ErrorFault 

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

func (*ConnectorAuthenticationException) ErrorMessage 

func (e *ConnectorAuthenticationException) ErrorMessage() string

type ConnectorConfiguration 

type ConnectorConfiguration struct {

	// The authentication config required for the connector.
	AuthenticationConfig *AuthenticationConfig

	//  Specifies whether the connector can be used as a destination.
	CanUseAsDestination bool

	//  Specifies whether the connector can be used as a source.
	CanUseAsSource bool

	// The Amazon Resource Name (ARN) for the registered connector.
	ConnectorArn *string

	// A description about the connector.
	ConnectorDescription *string

	// The label used for registering the connector.
	ConnectorLabel *string

	//  Specifies connector-specific metadata such as oAuthScopes , supportedRegions ,
	// privateLinkServiceUrl , and so on.
	ConnectorMetadata *ConnectorMetadata

	// The connection modes that the connector supports.
	ConnectorModes []string

	// The connector name.
	ConnectorName *string

	// The owner who developed the connector.
	ConnectorOwner *string

	// The configuration required for registering the connector.
	ConnectorProvisioningConfig *ConnectorProvisioningConfig

	// The provisioning type used to register the connector.
	ConnectorProvisioningType ConnectorProvisioningType

	// The required connector runtime settings.
	ConnectorRuntimeSettings []ConnectorRuntimeSetting

	// The connector type.
	ConnectorType ConnectorType

	// The connector version.
	ConnectorVersion *string

	//  Specifies if PrivateLink is enabled for that connector.
	IsPrivateLinkEnabled bool

	//  Specifies if a PrivateLink endpoint URL is required.
	IsPrivateLinkEndpointUrlRequired bool

	// Logo URL of the connector.
	LogoURL *string

	// The date on which the connector was registered.
	RegisteredAt *time.Time

	// Information about who registered the connector.
	RegisteredBy *string

	// A list of API versions that are supported by the connector.
	SupportedApiVersions []string

	// The APIs of the connector application that Amazon AppFlow can use to transfer
	// your data.
	SupportedDataTransferApis []DataTransferApi

	// The data transfer types that the connector supports.
	//
	// RECORD Structured records.
	//
	// FILE Files or binary data.
	SupportedDataTransferTypes []SupportedDataTransferType

	//  Lists the connectors that are available for use as destinations.
	SupportedDestinationConnectors []ConnectorType

	// A list of operators supported by the connector.
	SupportedOperators []Operators

	//  Specifies the supported flow frequency for that connector.
	SupportedSchedulingFrequencies []ScheduleFrequencyType

	//  Specifies the supported trigger types for the flow.
	SupportedTriggerTypes []TriggerType

	// A list of write operations supported by the connector.
	SupportedWriteOperations []WriteOperationType
	// contains filtered or unexported fields
}

The configuration settings related to a given connector.

type ConnectorDetail 

type ConnectorDetail struct {

	// The application type of the connector.
	ApplicationType *string

	// A description about the registered connector.
	ConnectorDescription *string

	// A label used for the connector.
	ConnectorLabel *string

	// The connection mode that the connector supports.
	ConnectorModes []string

	// The name of the connector.
	ConnectorName *string

	// The owner of the connector.
	ConnectorOwner *string

	// The provisioning type that the connector uses.
	ConnectorProvisioningType ConnectorProvisioningType

	// The connector type.
	ConnectorType ConnectorType

	// The connector version.
	ConnectorVersion *string

	// The time at which the connector was registered.
	RegisteredAt *time.Time

	// The user who registered the connector.
	RegisteredBy *string

	// The data transfer types that the connector supports.
	//
	// RECORD Structured records.
	//
	// FILE Files or binary data.
	SupportedDataTransferTypes []SupportedDataTransferType
	// contains filtered or unexported fields
}

Information about the registered 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
	// contains filtered or unexported fields
}
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 map that has specific properties related to the ConnectorEntityField.
	CustomProperties map[string]string

	// Default value that can be assigned to this field.
	DefaultValue *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

	// Booelan value that indicates whether this field is deprecated or not.
	IsDeprecated bool

	// Booelan value that indicates whether this field can be used as a primary key.
	IsPrimaryKey bool

	//  The label applied to a connector entity field.
	Label *string

	// The parent identifier of the connector field.
	ParentIdentifier *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
	// contains filtered or unexported fields
}
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 Salesforce Pardot.
	Pardot *PardotMetadata

	//  The connector metadata specific to Amazon Redshift.
	Redshift *RedshiftMetadata

	//  The connector metadata specific to Amazon S3.
	S3 *S3Metadata

	//  The connector metadata specific to SAPOData.
	SAPOData *SAPODataMetadata

	//  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
	// contains filtered or unexported fields
}
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
	// contains filtered or unexported fields
}
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

	// Operators supported by the custom connector.
	CustomConnector Operator

	//  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 Salesforce Pardot source fields.
	Pardot PardotConnectorOperator

	//  The operation to be performed on the provided Amazon S3 source fields.
	S3 S3ConnectorOperator

	//  The operation to be performed on the provided SAPOData source fields.
	SAPOData SAPODataConnectorOperator

	//  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
	// contains filtered or unexported fields
}

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 label for the connector profile being created.
	ConnectorLabel *string

	//  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 Amazon Web Services 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

	//  Specifies the private connection provisioning state.
	PrivateConnectionProvisioningState *PrivateConnectionProvisioningState
	// contains filtered or unexported fields
}
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 properties of the profile configuration.
	//
	// This member is required.
	ConnectorProfileProperties *ConnectorProfileProperties

	//  The connector-specific credentials required by each connector.
	ConnectorProfileCredentials *ConnectorProfileCredentials
	// contains filtered or unexported fields
}
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 profile credentials that are required when using the
	// custom connector.
	CustomConnector *CustomConnectorProfileCredentials

	//  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 Salesforce Pardot.
	Pardot *PardotConnectorProfileCredentials

	//  The connector-specific credentials required when using Amazon Redshift.
	Redshift *RedshiftConnectorProfileCredentials

	//  The connector-specific profile credentials required when using SAPOData.
	SAPOData *SAPODataConnectorProfileCredentials

	//  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
	// contains filtered or unexported fields
}

The connector-specific credentials required by a connector.

type ConnectorProfileProperties 

type ConnectorProfileProperties struct {

	//  The connector-specific properties required by Amplitude.
	Amplitude *AmplitudeConnectorProfileProperties

	// The properties required by the custom connector.
	CustomConnector *CustomConnectorProfileProperties

	//  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 Salesforce Pardot.
	Pardot *PardotConnectorProfileProperties

	//  The connector-specific properties required by Amazon Redshift.
	Redshift *RedshiftConnectorProfileProperties

	//  The connector-specific profile properties required when using SAPOData.
	SAPOData *SAPODataConnectorProfileProperties

	//  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
	// contains filtered or unexported fields
}

The connector-specific profile properties required by each connector.

type ConnectorProvisioningConfig 

type ConnectorProvisioningConfig struct {

	// Contains information about the configuration of the lambda which is being
	// registered as the connector.
	Lambda *LambdaConnectorProvisioningConfig
	// contains filtered or unexported fields
}

Contains information about the configuration of the connector being registered.

type ConnectorProvisioningType 

type ConnectorProvisioningType string
const (
	ConnectorProvisioningTypeLambda ConnectorProvisioningType = "LAMBDA"
)

Enum values for ConnectorProvisioningType

func (ConnectorProvisioningType) Values 

func (ConnectorProvisioningType) Values() []ConnectorProvisioningType

Values returns all known values for ConnectorProvisioningType. 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 ConnectorRuntimeSetting 

type ConnectorRuntimeSetting struct {

	// Contains default values for the connector runtime setting that are supplied by
	// the connector.
	ConnectorSuppliedValueOptions []string

	// Data type of the connector runtime setting.
	DataType *string

	// A description about the connector runtime setting.
	Description *string

	// Indicates whether this connector runtime setting is required.
	IsRequired bool

	// Contains value information about the connector runtime setting.
	Key *string

	// A label used for connector runtime setting.
	Label *string

	// Indicates the scope of the connector runtime setting.
	Scope *string
	// contains filtered or unexported fields
}

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

type ConnectorServerException 

type ConnectorServerException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

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"
	ConnectorTypeSapodata         ConnectorType = "SAPOData"
	ConnectorTypeCustomconnector  ConnectorType = "CustomConnector"
	ConnectorTypePardot           ConnectorType = "Pardot"
)

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 CustomAuthConfig 

type CustomAuthConfig struct {

	// Information about authentication parameters required for authentication.
	AuthParameters []AuthParameter

	// The authentication type that the custom connector uses.
	CustomAuthenticationType *string
	// contains filtered or unexported fields
}

Configuration information required for custom authentication.

type CustomAuthCredentials 

type CustomAuthCredentials struct {

	// The custom authentication type that the connector uses.
	//
	// This member is required.
	CustomAuthenticationType *string

	// A map that holds custom authentication credentials.
	CredentialsMap map[string]string
	// contains filtered or unexported fields
}

The custom credentials required for custom authentication.

type CustomConnectorDestinationProperties 

type CustomConnectorDestinationProperties struct {

	// The entity specified in the custom connector as a destination in the flow.
	//
	// This member is required.
	EntityName *string

	// The custom properties that are specific to the connector when it's used as a
	// destination in the flow.
	CustomProperties map[string]string

	// The settings that determine how Amazon AppFlow handles an error when placing
	// data in the custom connector as destination.
	ErrorHandlingConfig *ErrorHandlingConfig

	// The name of the field that Amazon AppFlow uses as an ID when performing a write
	// operation such as update, delete, or upsert.
	IdFieldNames []string

	// Specifies the type of write operation to be performed in the custom connector
	// when it's used as destination.
	WriteOperationType WriteOperationType
	// contains filtered or unexported fields
}

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

type CustomConnectorProfileCredentials 

type CustomConnectorProfileCredentials struct {

	// The authentication type that the custom connector uses for authenticating while
	// creating a connector profile.
	//
	// This member is required.
	AuthenticationType AuthenticationType

	// The API keys required for the authentication of the user.
	ApiKey *ApiKeyCredentials

	// The basic credentials that are required for the authentication of the user.
	Basic *BasicAuthCredentials

	// If the connector uses the custom authentication mechanism, this holds the
	// required credentials.
	Custom *CustomAuthCredentials

	// The OAuth 2.0 credentials required for the authentication of the user.
	Oauth2 *OAuth2Credentials
	// contains filtered or unexported fields
}

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

type CustomConnectorProfileProperties 

type CustomConnectorProfileProperties struct {

	// The OAuth 2.0 properties required for OAuth 2.0 authentication.
	OAuth2Properties *OAuth2Properties

	// A map of properties that are required to create a profile for the custom
	// connector.
	ProfileProperties map[string]string
	// contains filtered or unexported fields
}

The profile properties required by the custom connector.

type CustomConnectorSourceProperties 

type CustomConnectorSourceProperties struct {

	// The entity specified in the custom connector as a source in the flow.
	//
	// This member is required.
	EntityName *string

	// Custom properties that are required to use the custom connector as a source.
	CustomProperties map[string]string

	// The API of the connector application that Amazon AppFlow uses to transfer your
	// data.
	DataTransferApi *DataTransferApi
	// contains filtered or unexported fields
}

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

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
	// contains filtered or unexported fields
}
The properties that are applied when Amazon Connect Customer Profiles is used

as a destination.

type CustomerProfilesMetadata 

type CustomerProfilesMetadata struct {
	// contains filtered or unexported fields
}

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 DataTransferApi 

type DataTransferApi struct {

	// The name of the connector application API.
	Name *string

	// You can specify one of the following types:
	//
	// AUTOMATIC The default. Optimizes a flow for datasets that fluctuate in size
	// from small to large. For each flow run, Amazon AppFlow chooses to use the SYNC
	// or ASYNC API type based on the amount of data that the run transfers.
	//
	// SYNC A synchronous API. This type of API optimizes a flow for small to
	// medium-sized datasets.
	//
	// ASYNC An asynchronous API. This type of API optimizes a flow for large datasets.
	Type DataTransferApiType
	// contains filtered or unexported fields
}

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

type DataTransferApiType 

type DataTransferApiType string
const (
	DataTransferApiTypeSync      DataTransferApiType = "SYNC"
	DataTransferApiTypeAsync     DataTransferApiType = "ASYNC"
	DataTransferApiTypeAutomatic DataTransferApiType = "AUTOMATIC"
)

Enum values for DataTransferApiType

func (DataTransferApiType) Values 

func (DataTransferApiType) Values() []DataTransferApiType

Values returns all known values for DataTransferApiType. 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 

func (DatadogConnectorOperator) Values() []DatadogConnectorOperator

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
	// contains filtered or unexported fields
}

The connector-specific credentials required by Datadog.

type DatadogConnectorProfileProperties 

type DatadogConnectorProfileProperties struct {

	//  The location of the Datadog resource.
	//
	// This member is required.
	InstanceUrl *string
	// contains filtered or unexported fields
}

The connector-specific profile properties required by Datadog.

type DatadogMetadata 

type DatadogMetadata struct {
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

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

type DestinationConnectorProperties 

type DestinationConnectorProperties struct {

	// The properties that are required to query the custom Connector.
	CustomConnector *CustomConnectorDestinationProperties

	//  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 Marketo.
	Marketo *MarketoDestinationProperties

	//  The properties required to query Amazon Redshift.
	Redshift *RedshiftDestinationProperties

	//  The properties required to query Amazon S3.
	S3 *S3DestinationProperties

	// The properties required to query SAPOData.
	SAPOData *SAPODataDestinationProperties

	//  The properties required to query Salesforce.
	Salesforce *SalesforceDestinationProperties

	//  The properties required to query Snowflake.
	Snowflake *SnowflakeDestinationProperties

	//  The properties required to query Upsolver.
	Upsolver *UpsolverDestinationProperties

	// The properties required to query Zendesk.
	Zendesk *ZendeskDestinationProperties
	// contains filtered or unexported fields
}

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 whether the field can use the default value during a Create operation.
	IsDefaultedOnCreate 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
	// contains filtered or unexported fields
}
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 API version that the destination connector uses.
	ApiVersion *string

	//  The name of the connector profile. This name must be unique for each connector
	// profile in the Amazon Web Services account.
	ConnectorProfileName *string
	// contains filtered or unexported fields
}
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 

func (DynatraceConnectorOperator) Values() []DynatraceConnectorOperator

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
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

The connector-specific profile properties required by Dynatrace.

type DynatraceMetadata 

type DynatraceMetadata struct {
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}
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
	// contains filtered or unexported fields
}
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
	// contains filtered or unexported fields
}
The properties that are applied when Amazon EventBridge is being used as a

destination.

type EventBridgeMetadata 

type EventBridgeMetadata struct {
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}
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

	// Describes the metadata catalog, metadata table, and data partitions that Amazon
	// AppFlow used for the associated flow run.
	MetadataCatalogDetails []MetadataCatalogDetail

	//  Specifies the start time of the flow run.
	StartedAt *time.Time
	// contains filtered or unexported fields
}

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 maximum number of records that Amazon AppFlow receives in each page of the
	// response from your SAP application.
	MaxPageSize *int64

	// The number of processes that Amazon AppFlow ran at the same time when it
	// retrieved your data.
	NumParallelProcesses *int64

	//  The number of records processed in the flow run.
	RecordsProcessed *int64
	// contains filtered or unexported fields
}

Specifies the end result of the flow run.

type ExecutionStatus 

type ExecutionStatus string
const (
	ExecutionStatusInprogress    ExecutionStatus = "InProgress"
	ExecutionStatusSuccessful    ExecutionStatus = "Successful"
	ExecutionStatusError         ExecutionStatus = "Error"
	ExecutionStatusCancelstarted ExecutionStatus = "CancelStarted"
	ExecutionStatusCanceled      ExecutionStatus = "Canceled"
)

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

	// This is the allowable length range for this field's value.
	FieldLengthRange *Range

	// The range of values this field can hold.
	FieldValueRange *Range

	// The date format that the field supports.
	SupportedDateFormat *string

	//  The list of values that a field can contain. For example, a Boolean fieldType
	// can have two values: "true" and "false".
	SupportedValues []string

	// The regular expression pattern for the field name.
	ValueRegexPattern *string
	// contains filtered or unexported fields
}
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

	// The label of the destination connector in the flow.
	DestinationConnectorLabel *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

	// The label of the source connector in the flow.
	SourceConnectorLabel *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
	// contains filtered or unexported fields
}
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 GlueDataCatalogConfig 

type GlueDataCatalogConfig struct {

	// The name of the Data Catalog database that stores the metadata tables that
	// Amazon AppFlow creates in your Amazon Web Services account. These tables contain
	// metadata for the data that's transferred by the flow that you configure with
	// this parameter.
	//
	// When you configure a new flow with this parameter, you must specify an existing
	// database.
	//
	// This member is required.
	DatabaseName *string

	// The Amazon Resource Name (ARN) of an IAM role that grants Amazon AppFlow the
	// permissions it needs to create Data Catalog tables, databases, and partitions.
	//
	// For an example IAM policy that has the required permissions, see [Identity-based policy examples for Amazon AppFlow].
	//
	// [Identity-based policy examples for Amazon AppFlow]: https://docs.aws.amazon.com/appflow/latest/userguide/security_iam_id-based-policy-examples.html
	//
	// This member is required.
	RoleArn *string

	// A naming prefix for each Data Catalog table that Amazon AppFlow creates for the
	// flow that you configure with this setting. Amazon AppFlow adds the prefix to the
	// beginning of the each table name.
	//
	// This member is required.
	TablePrefix *string
	// contains filtered or unexported fields
}

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

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

type GoogleAnalyticsConnectorOperator 

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

Enum values for GoogleAnalyticsConnectorOperator

func (GoogleAnalyticsConnectorOperator) Values 

func (GoogleAnalyticsConnectorOperator) Values() []GoogleAnalyticsConnectorOperator

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
	// contains filtered or unexported fields
}

The connector-specific profile credentials required by Google Analytics.

type GoogleAnalyticsConnectorProfileProperties 

type GoogleAnalyticsConnectorProfileProperties struct {
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}
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
	// contains filtered or unexported fields
}

The connector-specific credentials required when using Amazon Honeycode.

type HoneycodeConnectorProfileProperties 

type HoneycodeConnectorProfileProperties struct {
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}
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
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}
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 

func (InforNexusConnectorOperator) Values() []InforNexusConnectorOperator

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
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

The connector-specific profile properties required by Infor Nexus.

type InforNexusMetadata 

type InforNexusMetadata struct {
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

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

type InternalServerException 

type InternalServerException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}
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 LambdaConnectorProvisioningConfig 

type LambdaConnectorProvisioningConfig struct {

	// Lambda ARN of the connector being registered.
	//
	// This member is required.
	LambdaArn *string
	// contains filtered or unexported fields
}

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

type LookoutMetricsDestinationProperties 

type LookoutMetricsDestinationProperties struct {
	// contains filtered or unexported fields
}
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 

func (MarketoConnectorOperator) Values() []MarketoConnectorOperator

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
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

The connector-specific profile properties required when using Marketo.

type MarketoDestinationProperties 

type MarketoDestinationProperties struct {

	// The object specified in the Marketo 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
	// contains filtered or unexported fields
}

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

type MarketoMetadata 

type MarketoMetadata struct {
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

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

type MetadataCatalogConfig 

type MetadataCatalogConfig struct {

	// Specifies the configuration that Amazon AppFlow uses when it catalogs your data
	// with the Glue Data Catalog.
	GlueDataCatalog *GlueDataCatalogConfig
	// contains filtered or unexported fields
}

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

type MetadataCatalogDetail 

type MetadataCatalogDetail struct {

	// The type of metadata catalog that Amazon AppFlow used for the associated flow
	// run. This parameter returns the following value:
	//
	// GLUE The metadata catalog is provided by the Glue Data Catalog. Glue includes
	// the Glue Data Catalog as a component.
	CatalogType CatalogType

	// Describes the status of the attempt from Amazon AppFlow to register the data
	// partitions with the metadata catalog. The data partitions organize the flow
	// output into a hierarchical path, such as a folder path in an S3 bucket. Amazon
	// AppFlow creates the partitions (if they don't already exist) based on your flow
	// configuration.
	PartitionRegistrationOutput *RegistrationOutput

	// The name of the table that stores the metadata for the associated flow run. The
	// table stores metadata that represents the data that the flow transferred. Amazon
	// AppFlow stores the table in the metadata catalog.
	TableName *string

	// Describes the status of the attempt from Amazon AppFlow to register the
	// metadata table with the metadata catalog. Amazon AppFlow creates or updates this
	// table for the associated flow run.
	TableRegistrationOutput *RegistrationOutput
	// contains filtered or unexported fields
}

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

type OAuth2Credentials 

type OAuth2Credentials struct {

	// The access token used to access the connector on your behalf.
	AccessToken *string

	// The identifier for the desired client.
	ClientId *string

	// The client secret used by the OAuth client to authenticate to the authorization
	// server.
	ClientSecret *string

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

	// The refresh token used to refresh an expired access token.
	RefreshToken *string
	// contains filtered or unexported fields
}

The OAuth 2.0 credentials required for OAuth 2.0 authentication.

type OAuth2CustomParameter 

type OAuth2CustomParameter struct {

	// Contains default values for this authentication parameter that are supplied by
	// the connector.
	ConnectorSuppliedValues []string

	// A description about the custom parameter used for OAuth 2.0 authentication.
	Description *string

	// Indicates whether the custom parameter for OAuth 2.0 authentication is required.
	IsRequired bool

	// Indicates whether this authentication custom parameter is a sensitive field.
	IsSensitiveField bool

	// The key of the custom parameter required for OAuth 2.0 authentication.
	Key *string

	// The label of the custom parameter used for OAuth 2.0 authentication.
	Label *string

	// Indicates whether custom parameter is used with TokenUrl or AuthUrl.
	Type OAuth2CustomPropType
	// contains filtered or unexported fields
}

Custom parameter required for OAuth 2.0 authentication.

type OAuth2CustomPropType 

type OAuth2CustomPropType string
const (
	OAuth2CustomPropTypeTokenUrl OAuth2CustomPropType = "TOKEN_URL"
	OAuth2CustomPropTypeAuthUrl  OAuth2CustomPropType = "AUTH_URL"
)

Enum values for OAuth2CustomPropType

func (OAuth2CustomPropType) Values 

func (OAuth2CustomPropType) Values() []OAuth2CustomPropType

Values returns all known values for OAuth2CustomPropType. 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 OAuth2Defaults 

type OAuth2Defaults struct {

	// Auth code URLs that can be used for OAuth 2.0 authentication.
	AuthCodeUrls []string

	// List of custom parameters required for OAuth 2.0 authentication.
	Oauth2CustomProperties []OAuth2CustomParameter

	// OAuth 2.0 grant types supported by the connector.
	Oauth2GrantTypesSupported []OAuth2GrantType

	// OAuth 2.0 scopes that the connector supports.
	OauthScopes []string

	// Token URLs that can be used for OAuth 2.0 authentication.
	TokenUrls []string
	// contains filtered or unexported fields
}

Contains the default values required for OAuth 2.0 authentication.

type OAuth2GrantType 

type OAuth2GrantType string
const (
	OAuth2GrantTypeClientCredentials OAuth2GrantType = "CLIENT_CREDENTIALS"
	OAuth2GrantTypeAuthorizationCode OAuth2GrantType = "AUTHORIZATION_CODE"
	OAuth2GrantTypeJwtBearer         OAuth2GrantType = "JWT_BEARER"
)

Enum values for OAuth2GrantType

func (OAuth2GrantType) Values 

func (OAuth2GrantType) Values() []OAuth2GrantType

Values returns all known values for OAuth2GrantType. 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 OAuth2Properties 

type OAuth2Properties struct {

	// The OAuth 2.0 grant type used by connector for OAuth 2.0 authentication.
	//
	// This member is required.
	OAuth2GrantType OAuth2GrantType

	// The token URL required for OAuth 2.0 authentication.
	//
	// This member is required.
	TokenUrl *string

	// Associates your token URL with a map of properties that you define. Use this
	// parameter to provide any additional details that the connector requires to
	// authenticate your request.
	TokenUrlCustomProperties map[string]string
	// contains filtered or unexported fields
}

The OAuth 2.0 properties required for OAuth 2.0 authentication.

type OAuthCredentials 

type OAuthCredentials 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 access token used to access protected SAPOData resources.
	AccessToken *string

	//  The OAuth requirement needed to request security tokens from the connector
	// endpoint.
	OAuthRequest *ConnectorOAuthRequest

	//  The refresh token used to refresh expired access token.
	RefreshToken *string
	// contains filtered or unexported fields
}

The OAuth credentials required for OAuth type authentication.

type OAuthProperties 

type OAuthProperties struct {

	//  The authorization code url required to redirect to SAP Login Page to fetch
	// authorization code for OAuth type authentication.
	//
	// This member is required.
	AuthCodeUrl *string

	//  The OAuth scopes required for OAuth type authentication.
	//
	// This member is required.
	OAuthScopes []string

	//  The token url required to fetch access/refresh tokens using authorization code
	// and also to refresh expired access token using refresh token.
	//
	// This member is required.
	TokenUrl *string
	// contains filtered or unexported fields
}

The OAuth properties required for OAuth type authentication.

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"
	OperatorPropertiesKeysExcludeSourceFieldsList  OperatorPropertiesKeys = "EXCLUDE_SOURCE_FIELDS_LIST"
	OperatorPropertiesKeysIncludeNewFields         OperatorPropertiesKeys = "INCLUDE_NEW_FIELDS"
	OperatorPropertiesKeysOrderedPartitionKeysList OperatorPropertiesKeys = "ORDERED_PARTITION_KEYS_LIST"
)

Enum values for OperatorPropertiesKeys

func (OperatorPropertiesKeys) Values 

func (OperatorPropertiesKeys) Values() []OperatorPropertiesKeys

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 Operators 

type Operators string
const (
	OperatorsProjection           Operators = "PROJECTION"
	OperatorsLessThan             Operators = "LESS_THAN"
	OperatorsGreaterThan          Operators = "GREATER_THAN"
	OperatorsContains             Operators = "CONTAINS"
	OperatorsBetween              Operators = "BETWEEN"
	OperatorsLessThanOrEqualTo    Operators = "LESS_THAN_OR_EQUAL_TO"
	OperatorsGreaterThanOrEqualTo Operators = "GREATER_THAN_OR_EQUAL_TO"
	OperatorsEqualTo              Operators = "EQUAL_TO"
	OperatorsNotEqualTo           Operators = "NOT_EQUAL_TO"
	OperatorsAddition             Operators = "ADDITION"
	OperatorsMultiplication       Operators = "MULTIPLICATION"
	OperatorsDivision             Operators = "DIVISION"
	OperatorsSubtraction          Operators = "SUBTRACTION"
	OperatorsMaskAll              Operators = "MASK_ALL"
	OperatorsMaskFirstN           Operators = "MASK_FIRST_N"
	OperatorsMaskLastN            Operators = "MASK_LAST_N"
	OperatorsValidateNonNull      Operators = "VALIDATE_NON_NULL"
	OperatorsValidateNonZero      Operators = "VALIDATE_NON_ZERO"
	OperatorsValidateNonNegative  Operators = "VALIDATE_NON_NEGATIVE"
	OperatorsValidateNumeric      Operators = "VALIDATE_NUMERIC"
	OperatorsNoOp                 Operators = "NO_OP"
)

Enum values for Operators

func (Operators) Values 

func (Operators) Values() []Operators

Values returns all known values for Operators. 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 PardotConnectorOperator 

type PardotConnectorOperator string
const (
	PardotConnectorOperatorProjection          PardotConnectorOperator = "PROJECTION"
	PardotConnectorOperatorEqualTo             PardotConnectorOperator = "EQUAL_TO"
	PardotConnectorOperatorNoOp                PardotConnectorOperator = "NO_OP"
	PardotConnectorOperatorAddition            PardotConnectorOperator = "ADDITION"
	PardotConnectorOperatorMultiplication      PardotConnectorOperator = "MULTIPLICATION"
	PardotConnectorOperatorDivision            PardotConnectorOperator = "DIVISION"
	PardotConnectorOperatorSubtraction         PardotConnectorOperator = "SUBTRACTION"
	PardotConnectorOperatorMaskAll             PardotConnectorOperator = "MASK_ALL"
	PardotConnectorOperatorMaskFirstN          PardotConnectorOperator = "MASK_FIRST_N"
	PardotConnectorOperatorMaskLastN           PardotConnectorOperator = "MASK_LAST_N"
	PardotConnectorOperatorValidateNonNull     PardotConnectorOperator = "VALIDATE_NON_NULL"
	PardotConnectorOperatorValidateNonZero     PardotConnectorOperator = "VALIDATE_NON_ZERO"
	PardotConnectorOperatorValidateNonNegative PardotConnectorOperator = "VALIDATE_NON_NEGATIVE"
	PardotConnectorOperatorValidateNumeric     PardotConnectorOperator = "VALIDATE_NUMERIC"
)

Enum values for PardotConnectorOperator

func (PardotConnectorOperator) Values 

func (PardotConnectorOperator) Values() []PardotConnectorOperator

Values returns all known values for PardotConnectorOperator. 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 PardotConnectorProfileCredentials 

type PardotConnectorProfileCredentials struct {

	// The credentials used to access protected Salesforce Pardot resources.
	AccessToken *string

	// The secret manager ARN, which contains the client ID and client secret of the
	// connected app.
	ClientCredentialsArn *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
	// contains filtered or unexported fields
}

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

type PardotConnectorProfileProperties 

type PardotConnectorProfileProperties struct {

	// The business unit id of Salesforce Pardot instance.
	BusinessUnitId *string

	// The location of the Salesforce Pardot resource.
	InstanceUrl *string

	// Indicates whether the connector profile applies to a sandbox or production
	// environment.
	IsSandboxEnvironment bool
	// contains filtered or unexported fields
}

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

type PardotMetadata 

type PardotMetadata struct {
	// contains filtered or unexported fields
}

The connector metadata specific to Salesforce Pardot.

type PardotSourceProperties 

type PardotSourceProperties struct {

	// The object specified in the Salesforce Pardot flow source.
	//
	// This member is required.
	Object *string
	// contains filtered or unexported fields
}

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

type PathPrefix 

type PathPrefix string
const (
	PathPrefixExecutionId   PathPrefix = "EXECUTION_ID"
	PathPrefixSchemaVersion PathPrefix = "SCHEMA_VERSION"
)

Enum values for PathPrefix

func (PathPrefix) Values 

func (PathPrefix) Values() []PathPrefix

Values returns all known values for PathPrefix. 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 {

	// Specifies whether the destination file path includes either or both of the
	// following elements:
	//
	// EXECUTION_ID The ID that Amazon AppFlow assigns to the flow run.
	//
	// SCHEMA_VERSION The version number of your data schema. Amazon AppFlow assigns
	// this version number. The version number increases by one when you change any of
	// the following settings in your flow configuration:
	//
	//   - Source-to-destination field mappings
	//
	//   - Field data types
	//
	//   - Partition keys
	PathPrefixHierarchy []PathPrefix

	// Determines the level of granularity for the date and time 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
	// contains filtered or unexported fields
}

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

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 PrivateConnectionProvisioningFailureCause 

type PrivateConnectionProvisioningFailureCause string
const (
	PrivateConnectionProvisioningFailureCauseConnectorAuthentication PrivateConnectionProvisioningFailureCause = "CONNECTOR_AUTHENTICATION"
	PrivateConnectionProvisioningFailureCauseConnectorServer         PrivateConnectionProvisioningFailureCause = "CONNECTOR_SERVER"
	PrivateConnectionProvisioningFailureCauseInternalServer          PrivateConnectionProvisioningFailureCause = "INTERNAL_SERVER"
	PrivateConnectionProvisioningFailureCauseAccessDenied            PrivateConnectionProvisioningFailureCause = "ACCESS_DENIED"
	PrivateConnectionProvisioningFailureCauseValidation              PrivateConnectionProvisioningFailureCause = "VALIDATION"
)

Enum values for PrivateConnectionProvisioningFailureCause

func (PrivateConnectionProvisioningFailureCause) Values 

func (PrivateConnectionProvisioningFailureCause) Values() []PrivateConnectionProvisioningFailureCause

Values returns all known values for PrivateConnectionProvisioningFailureCause. 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 PrivateConnectionProvisioningState 

type PrivateConnectionProvisioningState struct {

	//  Specifies the private connection provisioning failure cause.
	FailureCause PrivateConnectionProvisioningFailureCause

	//  Specifies the private connection provisioning failure reason.
	FailureMessage *string

	//  Specifies the private connection provisioning status.
	Status PrivateConnectionProvisioningStatus
	// contains filtered or unexported fields
}

Specifies the private connection provisioning state.

type PrivateConnectionProvisioningStatus 

type PrivateConnectionProvisioningStatus string
const (
	PrivateConnectionProvisioningStatusFailed  PrivateConnectionProvisioningStatus = "FAILED"
	PrivateConnectionProvisioningStatusPending PrivateConnectionProvisioningStatus = "PENDING"
	PrivateConnectionProvisioningStatusCreated PrivateConnectionProvisioningStatus = "CREATED"
)

Enum values for PrivateConnectionProvisioningStatus

func (PrivateConnectionProvisioningStatus) Values 

func (PrivateConnectionProvisioningStatus) Values() []PrivateConnectionProvisioningStatus

Values returns all known values for PrivateConnectionProvisioningStatus. 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 Range 

type Range struct {

	// Maximum value supported by the field.
	Maximum float64

	// Minimum value supported by the field.
	Minimum float64
	// contains filtered or unexported fields
}

The range of values that the property supports.

type RedshiftConnectorProfileCredentials 

type RedshiftConnectorProfileCredentials struct {

	//  The password that corresponds to the user name.
	Password *string

	//  The name of the user.
	Username *string
	// contains filtered or unexported fields
}
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 Amazon Resource Name (ARN) of IAM role that grants Amazon Redshift
	// read-only access to Amazon S3. For more information, and for the polices that
	// you attach to this role, see [Allow Amazon Redshift to access your Amazon AppFlow data in Amazon S3].
	//
	// [Allow Amazon Redshift to access your Amazon AppFlow data in Amazon S3]: https://docs.aws.amazon.com/appflow/latest/userguide/security_iam_service-role-policies.html#redshift-access-s3
	//
	// This member is required.
	RoleArn *string

	//  The object key for the destination bucket in which Amazon AppFlow places the
	// files.
	BucketPrefix *string

	// The unique ID that's assigned to an Amazon Redshift cluster.
	ClusterIdentifier *string

	// The Amazon Resource Name (ARN) of an IAM role that permits Amazon AppFlow to
	// access your Amazon Redshift database through the Data API. For more information,
	// and for the polices that you attach to this role, see [Allow Amazon AppFlow to access Amazon Redshift databases with the Data API].
	//
	// [Allow Amazon AppFlow to access Amazon Redshift databases with the Data API]: https://docs.aws.amazon.com/appflow/latest/userguide/security_iam_service-role-policies.html#access-redshift
	DataApiRoleArn *string

	// The name of an Amazon Redshift database.
	DatabaseName *string

	//  The JDBC URL of the Amazon Redshift cluster.
	DatabaseUrl *string

	// Indicates whether the connector profile defines a connection to an Amazon
	// Redshift Serverless data warehouse.
	IsRedshiftServerless bool

	// The name of an Amazon Redshift workgroup.
	WorkgroupName *string
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}
The properties that are applied when Amazon Redshift is being used as a

destination.

type RedshiftMetadata 

type RedshiftMetadata struct {
	// contains filtered or unexported fields
}

The connector metadata specific to Amazon Redshift.

type RegistrationOutput 

type RegistrationOutput struct {

	// Explains the status of the registration attempt from Amazon AppFlow. If the
	// attempt fails, the message explains why.
	Message *string

	// Indicates the number of resources that Amazon AppFlow created or updated.
	// Possible resources include metadata tables and data partitions.
	Result *string

	// Indicates the status of the registration attempt from Amazon AppFlow.
	Status ExecutionStatus
	// contains filtered or unexported fields
}

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

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

type ResourceNotFoundException 

type ResourceNotFoundException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}
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 (e *ResourceNotFoundException) ErrorFault() smithy.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 

func (S3ConnectorOperator) Values() []S3ConnectorOperator

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
	// contains filtered or unexported fields
}

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

type S3InputFileType 

type S3InputFileType string
const (
	S3InputFileTypeCsv  S3InputFileType = "CSV"
	S3InputFileTypeJson S3InputFileType = "JSON"
)

Enum values for S3InputFileType

func (S3InputFileType) Values 

func (S3InputFileType) Values() []S3InputFileType

Values returns all known values for S3InputFileType. 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 S3InputFormatConfig 

type S3InputFormatConfig struct {

	//  The file type that Amazon AppFlow gets from your Amazon S3 bucket.
	S3InputFileType S3InputFileType
	// contains filtered or unexported fields
}
When you use Amazon S3 as the source, the configuration format that you

provide the flow input data.

type S3Metadata 

type S3Metadata struct {
	// contains filtered or unexported fields
}

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

	// If your file output format is Parquet, use this parameter to set whether Amazon
	// AppFlow preserves the data types in your source data when it writes the output
	// to Amazon S3.
	//
	//   - true : Amazon AppFlow preserves the data types when it writes to Amazon S3.
	//   For example, an integer or 1 in your source data is still an integer in your
	//   output.
	//
	//   - false : Amazon AppFlow converts all of the source data into strings when it
	//   writes to Amazon S3. For example, an integer of 1 in your source data becomes
	//   the string "1" in the output.
	PreserveSourceDataTyping *bool
	// contains filtered or unexported fields
}
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

	//  When you use Amazon S3 as the source, the configuration format that you
	// provide the flow input data.
	S3InputFormatConfig *S3InputFormatConfig
	// contains filtered or unexported fields
}
The properties that are applied when Amazon S3 is being used as the flow

source.

type SAPODataConnectorOperator 

type SAPODataConnectorOperator string
const (
	SAPODataConnectorOperatorProjection           SAPODataConnectorOperator = "PROJECTION"
	SAPODataConnectorOperatorLessThan             SAPODataConnectorOperator = "LESS_THAN"
	SAPODataConnectorOperatorContains             SAPODataConnectorOperator = "CONTAINS"
	SAPODataConnectorOperatorGreaterThan          SAPODataConnectorOperator = "GREATER_THAN"
	SAPODataConnectorOperatorBetween              SAPODataConnectorOperator = "BETWEEN"
	SAPODataConnectorOperatorLessThanOrEqualTo    SAPODataConnectorOperator = "LESS_THAN_OR_EQUAL_TO"
	SAPODataConnectorOperatorGreaterThanOrEqualTo SAPODataConnectorOperator = "GREATER_THAN_OR_EQUAL_TO"
	SAPODataConnectorOperatorEqualTo              SAPODataConnectorOperator = "EQUAL_TO"
	SAPODataConnectorOperatorNotEqualTo           SAPODataConnectorOperator = "NOT_EQUAL_TO"
	SAPODataConnectorOperatorAddition             SAPODataConnectorOperator = "ADDITION"
	SAPODataConnectorOperatorMultiplication       SAPODataConnectorOperator = "MULTIPLICATION"
	SAPODataConnectorOperatorDivision             SAPODataConnectorOperator = "DIVISION"
	SAPODataConnectorOperatorSubtraction          SAPODataConnectorOperator = "SUBTRACTION"
	SAPODataConnectorOperatorMaskAll              SAPODataConnectorOperator = "MASK_ALL"
	SAPODataConnectorOperatorMaskFirstN           SAPODataConnectorOperator = "MASK_FIRST_N"
	SAPODataConnectorOperatorMaskLastN            SAPODataConnectorOperator = "MASK_LAST_N"
	SAPODataConnectorOperatorValidateNonNull      SAPODataConnectorOperator = "VALIDATE_NON_NULL"
	SAPODataConnectorOperatorValidateNonZero      SAPODataConnectorOperator = "VALIDATE_NON_ZERO"
	SAPODataConnectorOperatorValidateNonNegative  SAPODataConnectorOperator = "VALIDATE_NON_NEGATIVE"
	SAPODataConnectorOperatorValidateNumeric      SAPODataConnectorOperator = "VALIDATE_NUMERIC"
	SAPODataConnectorOperatorNoOp                 SAPODataConnectorOperator = "NO_OP"
)

Enum values for SAPODataConnectorOperator

func (SAPODataConnectorOperator) Values 

func (SAPODataConnectorOperator) Values() []SAPODataConnectorOperator

Values returns all known values for SAPODataConnectorOperator. 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 SAPODataConnectorProfileCredentials 

type SAPODataConnectorProfileCredentials struct {

	//  The SAPOData basic authentication credentials.
	BasicAuthCredentials *BasicAuthCredentials

	//  The SAPOData OAuth type authentication credentials.
	OAuthCredentials *OAuthCredentials
	// contains filtered or unexported fields
}

The connector-specific profile credentials required when using SAPOData.

type SAPODataConnectorProfileProperties 

type SAPODataConnectorProfileProperties struct {

	//  The location of the SAPOData resource.
	//
	// This member is required.
	ApplicationHostUrl *string

	//  The application path to catalog service.
	//
	// This member is required.
	ApplicationServicePath *string

	//  The client number for the client creating the connection.
	//
	// This member is required.
	ClientNumber *string

	//  The port number of the SAPOData instance.
	//
	// This member is required.
	PortNumber *int32

	// If you set this parameter to true , Amazon AppFlow bypasses the single sign-on
	// (SSO) settings in your SAP account when it accesses your SAP OData instance.
	//
	// Whether you need this option depends on the types of credentials that you
	// applied to your SAP OData connection profile. If your profile uses basic
	// authentication credentials, SAP SSO can prevent Amazon AppFlow from connecting
	// to your account with your username and password. In this case, bypassing SSO
	// makes it possible for Amazon AppFlow to connect successfully. However, if your
	// profile uses OAuth credentials, this parameter has no affect.
	DisableSSO bool

	//  The logon language of SAPOData instance.
	LogonLanguage *string

	//  The SAPOData OAuth properties required for OAuth type authentication.
	OAuthProperties *OAuthProperties

	//  The SAPOData Private Link service name to be used for private data transfers.
	PrivateLinkServiceName *string
	// contains filtered or unexported fields
}

The connector-specific profile properties required when using SAPOData.

type SAPODataDestinationProperties 

type SAPODataDestinationProperties struct {

	// The object path specified in the SAPOData flow destination.
	//
	// This member is required.
	ObjectPath *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

	//  A list of field names that can be used as an ID field when performing a write
	// operation.
	IdFieldNames []string

	// Determines how Amazon AppFlow handles the success response that it gets from
	// the connector after placing data.
	//
	// For example, this setting would determine where to write the response from a
	// destination connector upon a successful insert operation.
	SuccessResponseHandlingConfig *SuccessResponseHandlingConfig

	//  The possible write operations in the destination connector. When this value is
	// not provided, this defaults to the INSERT operation.
	WriteOperationType WriteOperationType
	// contains filtered or unexported fields
}

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

type SAPODataMetadata 

type SAPODataMetadata struct {
	// contains filtered or unexported fields
}

The connector metadata specific to SAPOData.

type SAPODataPaginationConfig 

type SAPODataPaginationConfig struct {

	// The maximum number of records that Amazon AppFlow receives in each page of the
	// response from your SAP application. For transfers of OData records, the maximum
	// page size is 3,000. For transfers of data that comes from an ODP provider, the
	// maximum page size is 10,000.
	//
	// This member is required.
	MaxPageSize *int32
	// contains filtered or unexported fields
}

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

type SAPODataParallelismConfig 

type SAPODataParallelismConfig struct {

	// The maximum number of processes that Amazon AppFlow runs at the same time when
	// it retrieves your data from your SAP application.
	//
	// This member is required.
	MaxParallelism *int32
	// contains filtered or unexported fields
}

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

type SAPODataSourceProperties 

type SAPODataSourceProperties struct {

	//  The object path specified in the SAPOData flow source.
	ObjectPath *string

	// Sets the page size for each concurrent process that transfers OData records
	// from your SAP instance.
	PaginationConfig *SAPODataPaginationConfig

	// Sets the number of concurrent processes that transfers OData records from your
	// SAP instance.
	ParallelismConfig *SAPODataParallelismConfig
	// contains filtered or unexported fields
}

The properties that are applied when using SAPOData as a 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 

func (SalesforceConnectorOperator) Values() []SalesforceConnectorOperator

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

	// A JSON web token (JWT) that authorizes Amazon AppFlow to access your Salesforce
	// records.
	JwtToken *string

	// Specifies the OAuth 2.0 grant type that Amazon AppFlow uses when it requests an
	// access token from Salesforce. Amazon AppFlow requires an access token each time
	// it attempts to access your Salesforce records.
	//
	// You can specify one of the following values:
	//
	// AUTHORIZATION_CODE Amazon AppFlow passes an authorization code when it requests
	// the access token from Salesforce. Amazon AppFlow receives the authorization code
	// from Salesforce after you log in to your Salesforce account and authorize Amazon
	// AppFlow to access your records.
	//
	// CLIENT_CREDENTIALS Amazon AppFlow passes client credentials (a client ID and
	// client secret) when it requests the access token from Salesforce. You provide
	// these credentials to Amazon AppFlow when you define the connection to your
	// Salesforce account.
	//
	// JWT_BEARER Amazon AppFlow passes a JSON web token (JWT) when it requests the
	// access token from Salesforce. You provide the JWT to Amazon AppFlow when you
	// define the connection to your Salesforce account. When you use this grant type,
	// you don't need to log in to your Salesforce account to authorize Amazon AppFlow
	// to access your records.
	OAuth2GrantType OAuth2GrantType

	//  The OAuth requirement needed to request security tokens from the connector
	// endpoint.
	OAuthRequest *ConnectorOAuthRequest

	//  The credentials used to acquire new access tokens.
	RefreshToken *string
	// contains filtered or unexported fields
}

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

	// If the connection mode for the connector profile is private, this parameter
	// sets whether Amazon AppFlow uses the private network to send metadata and
	// authorization calls to Salesforce. Amazon AppFlow sends private calls through
	// Amazon Web Services PrivateLink. These calls travel through Amazon Web Services
	// infrastructure without being exposed to the public internet.
	//
	// Set either of the following values:
	//
	// true Amazon AppFlow sends all calls to Salesforce over the private network.
	//
	// These private calls are:
	//
	//   - Calls to get metadata about your Salesforce records. This metadata
	//   describes your Salesforce objects and their fields.
	//
	//   - Calls to get or refresh access tokens that allow Amazon AppFlow to access
	//   your Salesforce records.
	//
	//   - Calls to transfer your Salesforce records as part of a flow run.
	//
	// false The default value. Amazon AppFlow sends some calls to Salesforce
	// privately and other calls over the public internet.
	//
	// The public calls are:
	//
	//   - Calls to get metadata about your Salesforce records.
	//
	//   - Calls to get or refresh access tokens.
	//
	// The private calls are:
	//
	//   - Calls to transfer your Salesforce records as part of a flow run.
	UsePrivateLinkForMetadataAndAuthorization bool
	// contains filtered or unexported fields
}

The connector-specific profile properties required when using Salesforce.

type SalesforceDataTransferApi 

type SalesforceDataTransferApi string
const (
	SalesforceDataTransferApiAutomatic SalesforceDataTransferApi = "AUTOMATIC"
	SalesforceDataTransferApiBulkv2    SalesforceDataTransferApi = "BULKV2"
	SalesforceDataTransferApiRestSync  SalesforceDataTransferApi = "REST_SYNC"
)

Enum values for SalesforceDataTransferApi

func (SalesforceDataTransferApi) Values 

func (SalesforceDataTransferApi) Values() []SalesforceDataTransferApi

Values returns all known values for SalesforceDataTransferApi. 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 SalesforceDestinationProperties 

type SalesforceDestinationProperties struct {

	//  The object specified in the Salesforce flow destination.
	//
	// This member is required.
	Object *string

	// Specifies which Salesforce API is used by Amazon AppFlow when your flow
	// transfers data to Salesforce.
	//
	// AUTOMATIC The default. Amazon AppFlow selects which API to use based on the
	// number of records that your flow transfers to Salesforce. If your flow transfers
	// fewer than 1,000 records, Amazon AppFlow uses Salesforce REST API. If your flow
	// transfers 1,000 records or more, Amazon AppFlow uses Salesforce Bulk API 2.0.
	//
	// Each of these Salesforce APIs structures data differently. If Amazon AppFlow
	// selects the API automatically, be aware that, for recurring flows, the data
	// output might vary from one flow run to the next. For example, if a flow runs
	// daily, it might use REST API on one day to transfer 900 records, and it might
	// use Bulk API 2.0 on the next day to transfer 1,100 records. For each of these
	// flow runs, the respective Salesforce API formats the data differently. Some of
	// the differences include how dates are formatted and null values are represented.
	// Also, Bulk API 2.0 doesn't transfer Salesforce compound fields.
	//
	// By choosing this option, you optimize flow performance for both small and large
	// data transfers, but the tradeoff is inconsistent formatting in the output.
	//
	// BULKV2 Amazon AppFlow uses only Salesforce Bulk API 2.0. This API runs
	// asynchronous data transfers, and it's optimal for large sets of data. By
	// choosing this option, you ensure that your flow writes consistent output, but
	// you optimize performance only for large data transfers.
	//
	// Note that Bulk API 2.0 does not transfer Salesforce compound fields.
	//
	// REST_SYNC Amazon AppFlow uses only Salesforce REST API. By choosing this
	// option, you ensure that your flow writes consistent output, but you decrease
	// performance for large data transfers that are better suited for Bulk API 2.0. In
	// some cases, if your flow attempts to transfer a vary large set of data, it might
	// fail with a timed out error.
	DataTransferApi SalesforceDataTransferApi

	//  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
	// contains filtered or unexported fields
}
The properties that are applied when Salesforce is being used as a

destination.

type SalesforceMetadata 

type SalesforceMetadata struct {

	// The Salesforce APIs that you can have Amazon AppFlow use when your flows
	// transfers data to or from Salesforce.
	DataTransferApis []SalesforceDataTransferApi

	//  The desired authorization scope for the Salesforce account.
	OAuthScopes []string

	// The OAuth 2.0 grant types that Amazon AppFlow can use when it requests an
	// access token from Salesforce. Amazon AppFlow requires an access token each time
	// it attempts to access your Salesforce records.
	//
	// AUTHORIZATION_CODE Amazon AppFlow passes an authorization code when it requests
	// the access token from Salesforce. Amazon AppFlow receives the authorization code
	// from Salesforce after you log in to your Salesforce account and authorize Amazon
	// AppFlow to access your records.
	//
	// CLIENT_CREDENTIALS Amazon AppFlow passes client credentials (a client ID and
	// client secret) when it requests the access token from Salesforce. You provide
	// these credentials to Amazon AppFlow when you define the connection to your
	// Salesforce account.
	//
	// JWT_BEARER Amazon AppFlow passes a JSON web token (JWT) when it requests the
	// access token from Salesforce. You provide the JWT to Amazon AppFlow when you
	// define the connection to your Salesforce account. When you use this grant type,
	// you don't need to log in to your Salesforce account to authorize Amazon AppFlow
	// to access your records.
	Oauth2GrantTypesSupported []OAuth2GrantType
	// contains filtered or unexported fields
}

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

	// Specifies which Salesforce API is used by Amazon AppFlow when your flow
	// transfers data from Salesforce.
	//
	// AUTOMATIC The default. Amazon AppFlow selects which API to use based on the
	// number of records that your flow transfers from Salesforce. If your flow
	// transfers fewer than 1,000,000 records, Amazon AppFlow uses Salesforce REST API.
	// If your flow transfers 1,000,000 records or more, Amazon AppFlow uses Salesforce
	// Bulk API 2.0.
	//
	// Each of these Salesforce APIs structures data differently. If Amazon AppFlow
	// selects the API automatically, be aware that, for recurring flows, the data
	// output might vary from one flow run to the next. For example, if a flow runs
	// daily, it might use REST API on one day to transfer 900,000 records, and it
	// might use Bulk API 2.0 on the next day to transfer 1,100,000 records. For each
	// of these flow runs, the respective Salesforce API formats the data differently.
	// Some of the differences include how dates are formatted and null values are
	// represented. Also, Bulk API 2.0 doesn't transfer Salesforce compound fields.
	//
	// By choosing this option, you optimize flow performance for both small and large
	// data transfers, but the tradeoff is inconsistent formatting in the output.
	//
	// BULKV2 Amazon AppFlow uses only Salesforce Bulk API 2.0. This API runs
	// asynchronous data transfers, and it's optimal for large sets of data. By
	// choosing this option, you ensure that your flow writes consistent output, but
	// you optimize performance only for large data transfers.
	//
	// Note that Bulk API 2.0 does not transfer Salesforce compound fields.
	//
	// REST_SYNC Amazon AppFlow uses only Salesforce REST API. By choosing this
	// option, you ensure that your flow writes consistent output, but you decrease
	// performance for large data transfers that are better suited for Bulk API 2.0. In
	// some cases, if your flow attempts to transfer a vary large set of data, it might
	// fail wituh a timed out error.
	DataTransferApi SalesforceDataTransferApi

	//  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
	// contains filtered or unexported fields
}

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 

func (ScheduleFrequencyType) Values() []ScheduleFrequencyType

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

	// Defines how many times a scheduled flow fails consecutively before Amazon
	// AppFlow deactivates it.
	FlowErrorDeactivationThreshold *int32

	// The time at which the scheduled flow ends. The time is formatted as a timestamp
	// that follows the ISO 8601 standard, such as 2022-04-27T13:00:00-07:00 .
	ScheduleEndTime *time.Time

	//  Specifies the optional offset that is added to the time interval for a
	// schedule-triggered flow.
	ScheduleOffset *int64

	// The time at which the scheduled flow starts. The time is formatted as a
	// timestamp that follows the ISO 8601 standard, such as 2022-04-26T13:00:00-07:00 .
	ScheduleStartTime *time.Time

	// Specifies the time zone used when referring to the dates and times of a
	// scheduled flow, such as America/New_York . This time zone is only a descriptive
	// label. It doesn't affect how Amazon AppFlow interprets the timestamps that you
	// specify to schedule the flow.
	//
	// If you want to schedule a flow by using times in a particular time zone,
	// indicate the time zone as a UTC offset in your timestamps. For example, the UTC
	// offsets for the America/New_York timezone are -04:00 EDT and -05:00 EST .
	Timezone *string
	// contains filtered or unexported fields
}
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 

func (ServiceNowConnectorOperator) Values() []ServiceNowConnectorOperator

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 OAuth 2.0 credentials required to authenticate the user.
	OAuth2Credentials *OAuth2Credentials

	//  The password that corresponds to the user name.
	Password *string

	//  The name of the user.
	Username *string
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

The connector-specific profile properties required when using ServiceNow.

type ServiceNowMetadata 

type ServiceNowMetadata struct {
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

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

type ServiceQuotaExceededException 

type ServiceQuotaExceededException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}
The request would cause a service quota (such as the number of flows) to be

exceeded.

func (*ServiceQuotaExceededException) Error 

func (e *ServiceQuotaExceededException) Error() string

func (*ServiceQuotaExceededException) ErrorCode 

func (e *ServiceQuotaExceededException) ErrorCode() string

func (*ServiceQuotaExceededException) ErrorFault 

func (e *ServiceQuotaExceededException) ErrorFault() smithy.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 

func (SingularConnectorOperator) Values() []SingularConnectorOperator

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
	// contains filtered or unexported fields
}

The connector-specific profile credentials required when using Singular.

type SingularConnectorProfileProperties 

type SingularConnectorProfileProperties struct {
	// contains filtered or unexported fields
}

The connector-specific profile properties required when using Singular.

type SingularMetadata 

type SingularMetadata struct {
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

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 

func (SlackConnectorOperator) Values() []SlackConnectorOperator

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
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

The connector-specific profile properties required when using Slack.

type SlackMetadata 

type SlackMetadata struct {

	//  The desired authorization scope for the Slack account.
	OAuthScopes []string
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

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 Amazon Web Services Region of the Snowflake account.
	Region *string
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

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

type SnowflakeMetadata 

type SnowflakeMetadata struct {

	//  Specifies the supported Amazon Web Services Regions when using Snowflake.
	SupportedRegions []string
	// contains filtered or unexported fields
}

The connector metadata specific to Snowflake.

type SourceConnectorProperties 

type SourceConnectorProperties struct {

	//  Specifies the information that is required for querying Amplitude.
	Amplitude *AmplitudeSourceProperties

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

	//  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 Salesforce Pardot.
	Pardot *PardotSourceProperties

	//  Specifies the information that is required for querying Amazon S3.
	S3 *S3SourceProperties

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

	//  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
	// contains filtered or unexported fields
}

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

	// Indicates if this timestamp field can be used for incremental queries.
	IsTimestampFieldForIncrementalQueries bool
	// contains filtered or unexported fields
}
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 API version of the connector when it's used as a source in the flow.
	ApiVersion *string

	//  The name of the connector profile. This name must be unique for each connector
	// profile in the Amazon Web Services 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 filtered or unexported fields
}
Contains information about the configuration of the source connector used in

the flow.

type SuccessResponseHandlingConfig 

type SuccessResponseHandlingConfig struct {

	// The name of the Amazon S3 bucket.
	BucketName *string

	// The Amazon S3 bucket prefix.
	BucketPrefix *string
	// contains filtered or unexported fields
}

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

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

type SupportedDataTransferType 

type SupportedDataTransferType string
const (
	SupportedDataTransferTypeRecord SupportedDataTransferType = "RECORD"
	SupportedDataTransferTypeFile   SupportedDataTransferType = "FILE"
)

Enum values for SupportedDataTransferType

func (SupportedDataTransferType) Values 

func (SupportedDataTransferType) Values() []SupportedDataTransferType

Values returns all known values for SupportedDataTransferType. 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 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 filtered or unexported fields
}
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
	// contains filtered or unexported fields
}
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"
	TaskTypeMapAll      TaskType = "Map_all"
	TaskTypeMask        TaskType = "Mask"
	TaskTypeMerge       TaskType = "Merge"
	TaskTypePassthrough TaskType = "Passthrough"
	TaskTypeTruncate    TaskType = "Truncate"
	TaskTypeValidate    TaskType = "Validate"
	TaskTypePartition   TaskType = "Partition"
)

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 ThrottlingException 

type ThrottlingException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

API calls have exceeded the maximum allowed API request rate per account and per Region.

func (*ThrottlingException) Error 

func (e *ThrottlingException) Error() string

func (*ThrottlingException) ErrorCode 

func (e *ThrottlingException) ErrorCode() string

func (*ThrottlingException) ErrorFault 

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

func (*ThrottlingException) ErrorMessage 

func (e *ThrottlingException) ErrorMessage() string

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 

func (TrendmicroConnectorOperator) Values() []TrendmicroConnectorOperator

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
	// contains filtered or unexported fields
}

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

type TrendmicroConnectorProfileProperties 

type TrendmicroConnectorProfileProperties struct {
	// contains filtered or unexported fields
}

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

type TrendmicroMetadata 

type TrendmicroMetadata struct {
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}
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
	// contains filtered or unexported fields
}
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

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

The requested operation is not supported for the current flow.

func (*UnsupportedOperationException) Error 

func (e *UnsupportedOperationException) Error() string

func (*UnsupportedOperationException) ErrorCode 

func (e *UnsupportedOperationException) ErrorCode() string

func (*UnsupportedOperationException) ErrorFault 

func (e *UnsupportedOperationException) ErrorFault() smithy.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
	// contains filtered or unexported fields
}

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

type UpsolverMetadata 

type UpsolverMetadata struct {
	// contains filtered or unexported fields
}

The connector metadata specific to Upsolver.

type UpsolverS3OutputFormatConfig 

type UpsolverS3OutputFormatConfig struct {

	// Specifies elements that Amazon AppFlow includes in the file and folder names in
	// the flow destination.
	//
	// 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
	// contains filtered or unexported fields
}
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

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

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 

func (VeevaConnectorOperator) Values() []VeevaConnectorOperator

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
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

The connector-specific profile properties required when using Veeva.

type VeevaMetadata 

type VeevaMetadata struct {
	// contains filtered or unexported fields
}

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 document type specified in the Veeva document extract flow.
	DocumentType *string

	// Boolean value to include All Versions of files in Veeva document extract flow.
	IncludeAllVersions bool

	// Boolean value to include file renditions in Veeva document extract flow.
	IncludeRenditions bool

	// Boolean value to include source files in Veeva document extract flow.
	IncludeSourceFiles bool
	// contains filtered or unexported fields
}

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"
	WriteOperationTypeDelete WriteOperationType = "DELETE"
)

Enum values for WriteOperationType

func (WriteOperationType) Values 

func (WriteOperationType) Values() []WriteOperationType

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 

func (ZendeskConnectorOperator) Values() []ZendeskConnectorOperator

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
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

The connector-specific profile properties required when using Zendesk.

type ZendeskDestinationProperties 

type ZendeskDestinationProperties struct {

	// The object specified in the Zendesk 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

	//  A list of field names that can be used as an ID field when performing a write
	// operation.
	IdFieldNames []string

	//  The possible write operations in the destination connector. When this value is
	// not provided, this defaults to the INSERT operation.
	WriteOperationType WriteOperationType
	// contains filtered or unexported fields
}

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

type ZendeskMetadata 

type ZendeskMetadata struct {

	//  The desired authorization scope for the Zendesk account.
	OAuthScopes []string
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

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

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.