types

package
v1.1.1 Latest Latest
Warning

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

 Go to latest Published: Feb 10, 2021 License: Apache-2.0 Imports: 3 Imported by: 1

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AggregationConfig 

type AggregationConfig struct {

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

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

type AggregationType 

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

Enum values for AggregationType

func (AggregationType) Values 

func (AggregationType) Values() []AggregationType

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

type AmplitudeConnectorOperator 

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

Enum values for AmplitudeConnectorOperator

func (AmplitudeConnectorOperator) Values 

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
}

The connector-specific credentials required when using Amplitude.

type AmplitudeConnectorProfileProperties 

type AmplitudeConnectorProfileProperties struct {
}

The connector-specific profile properties required when using Amplitude.

type AmplitudeMetadata 

type AmplitudeMetadata struct {
}

The connector metadata specific to Amplitude.

type AmplitudeSourceProperties 

type AmplitudeSourceProperties struct {

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

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

type ConflictException 

type ConflictException struct {
	Message *string
}

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

func (*ConflictException) Error 

func (e *ConflictException) Error() string

func (*ConflictException) ErrorCode 

func (e *ConflictException) ErrorCode() string

func (*ConflictException) ErrorFault 

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

func (*ConflictException) ErrorMessage 

func (e *ConflictException) ErrorMessage() string

type ConnectionMode 

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

Enum values for ConnectionMode

func (ConnectionMode) Values 

func (ConnectionMode) Values() []ConnectionMode

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

type ConnectorAuthenticationException 

type ConnectorAuthenticationException struct {
	Message *string
}

An error occurred when authenticating with the connector endpoint.

func (*ConnectorAuthenticationException) Error 

func (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 {

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

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

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

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

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

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

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

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

The configuration settings related to a given connector.

type ConnectorEntity 

type ConnectorEntity struct {

	// The name of the connector entity.
	//
	// This member is required.
	Name *string

	// Specifies whether the connector entity is a parent or a category and has more
	// entities nested underneath it. If another call is made with entitiesPath =
	// "the_current_entity_name_with_hasNestedEntities_true", then it returns the
	// nested entities underneath it. This provides a way to retrieve all supported
	// entities in a recursive fashion.
	HasNestedEntities bool

	// The label applied to the connector entity.
	Label *string
}

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

type ConnectorEntityField 

type ConnectorEntityField struct {

	// The unique identifier of the connector field.
	//
	// This member is required.
	Identifier *string

	// A description of the connector entity field.
	Description *string

	// The properties applied to a field when the connector is being used as a
	// destination.
	DestinationProperties *DestinationFieldProperties

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

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

	// Contains details regarding the supported FieldType, including the corresponding
	// filterOperators and supportedValues.
	SupportedFieldTypeDetails *SupportedFieldTypeDetails
}

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

type ConnectorMetadata 

type ConnectorMetadata struct {

	// The connector metadata specific to Amplitude.
	Amplitude *AmplitudeMetadata

	// The connector metadata specific to Datadog.
	Datadog *DatadogMetadata

	// The connector metadata specific to Dynatrace.
	Dynatrace *DynatraceMetadata

	// The connector metadata specific to Amazon EventBridge.
	EventBridge *EventBridgeMetadata

	// The connector metadata specific to Google Analytics.
	GoogleAnalytics *GoogleAnalyticsMetadata

	// The connector metadata specific to Infor Nexus.
	InforNexus *InforNexusMetadata

	// The connector metadata specific to Marketo.
	Marketo *MarketoMetadata

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

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

	// The connector metadata specific to Salesforce.
	Salesforce *SalesforceMetadata

	// The connector metadata specific to ServiceNow.
	ServiceNow *ServiceNowMetadata

	// The connector metadata specific to Singular.
	Singular *SingularMetadata

	// The connector metadata specific to Slack.
	Slack *SlackMetadata

	// The connector metadata specific to Snowflake.
	Snowflake *SnowflakeMetadata

	// The connector metadata specific to Trend Micro.
	Trendmicro *TrendmicroMetadata

	// The connector metadata specific to Upsolver.
	Upsolver *UpsolverMetadata

	// The connector metadata specific to Veeva.
	Veeva *VeevaMetadata

	// The connector metadata specific to Zendesk.
	Zendesk *ZendeskMetadata
}

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

type ConnectorOAuthRequest 

type ConnectorOAuthRequest struct {

	// The code provided by the connector when it has been authenticated via the
	// connected app.
	AuthCode *string

	// The URL to which the authentication server redirects the browser after
	// authorization has been granted.
	RedirectUri *string
}

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

type ConnectorOperator 

type ConnectorOperator struct {

	// The operation to be performed on the provided Amplitude source fields.
	Amplitude AmplitudeConnectorOperator

	// The operation to be performed on the provided Datadog source fields.
	Datadog DatadogConnectorOperator

	// The operation to be performed on the provided Dynatrace source fields.
	Dynatrace DynatraceConnectorOperator

	// The operation to be performed on the provided Google Analytics source fields.
	GoogleAnalytics GoogleAnalyticsConnectorOperator

	// The operation to be performed on the provided Infor Nexus source fields.
	InforNexus InforNexusConnectorOperator

	// The operation to be performed on the provided Marketo source fields.
	Marketo MarketoConnectorOperator

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

	// The operation to be performed on the provided Salesforce source fields.
	Salesforce SalesforceConnectorOperator

	// The operation to be performed on the provided ServiceNow source fields.
	ServiceNow ServiceNowConnectorOperator

	// The operation to be performed on the provided Singular source fields.
	Singular SingularConnectorOperator

	// The operation to be performed on the provided Slack source fields.
	Slack SlackConnectorOperator

	// The operation to be performed on the provided Trend Micro source fields.
	Trendmicro TrendmicroConnectorOperator

	// The operation to be performed on the provided Veeva source fields.
	Veeva VeevaConnectorOperator

	// The operation to be performed on the provided Zendesk source fields.
	Zendesk ZendeskConnectorOperator
}

The operation to be performed on the provided source fields.

type ConnectorProfile 

type ConnectorProfile struct {

	// Indicates the connection mode and if it is public or private.
	ConnectionMode ConnectionMode

	// The Amazon Resource Name (ARN) of the connector profile.
	ConnectorProfileArn *string

	// The name of the connector profile. The name is unique for each ConnectorProfile
	// in the AWS account.
	ConnectorProfileName *string

	// The connector-specific properties of the profile configuration.
	ConnectorProfileProperties *ConnectorProfileProperties

	// The type of connector, such as Salesforce, Amplitude, and so on.
	ConnectorType ConnectorType

	// Specifies when the connector profile was created.
	CreatedAt *time.Time

	// The Amazon Resource Name (ARN) of the connector profile credentials.
	CredentialsArn *string

	// Specifies when the connector profile was last updated.
	LastUpdatedAt *time.Time
}

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

type ConnectorProfileConfig 

type ConnectorProfileConfig struct {

	// The connector-specific credentials required by each connector.
	//
	// This member is required.
	ConnectorProfileCredentials *ConnectorProfileCredentials

	// The connector-specific properties of the profile configuration.
	//
	// This member is required.
	ConnectorProfileProperties *ConnectorProfileProperties
}

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

type ConnectorProfileCredentials 

type ConnectorProfileCredentials struct {

	// The connector-specific credentials required when using Amplitude.
	Amplitude *AmplitudeConnectorProfileCredentials

	// The connector-specific credentials required when using Datadog.
	Datadog *DatadogConnectorProfileCredentials

	// The connector-specific credentials required when using Dynatrace.
	Dynatrace *DynatraceConnectorProfileCredentials

	// The connector-specific credentials required when using Google Analytics.
	GoogleAnalytics *GoogleAnalyticsConnectorProfileCredentials

	// The connector-specific credentials required when using Infor Nexus.
	InforNexus *InforNexusConnectorProfileCredentials

	// The connector-specific credentials required when using Marketo.
	Marketo *MarketoConnectorProfileCredentials

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

	// The connector-specific credentials required when using Salesforce.
	Salesforce *SalesforceConnectorProfileCredentials

	// The connector-specific credentials required when using ServiceNow.
	ServiceNow *ServiceNowConnectorProfileCredentials

	// The connector-specific credentials required when using Singular.
	Singular *SingularConnectorProfileCredentials

	// The connector-specific credentials required when using Slack.
	Slack *SlackConnectorProfileCredentials

	// The connector-specific credentials required when using Snowflake.
	Snowflake *SnowflakeConnectorProfileCredentials

	// The connector-specific credentials required when using Trend Micro.
	Trendmicro *TrendmicroConnectorProfileCredentials

	// The connector-specific credentials required when using Veeva.
	Veeva *VeevaConnectorProfileCredentials

	// The connector-specific credentials required when using Zendesk.
	Zendesk *ZendeskConnectorProfileCredentials
}

The connector-specific credentials required by a connector.

type ConnectorProfileProperties 

type ConnectorProfileProperties struct {

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

	// The connector-specific properties required by Datadog.
	Datadog *DatadogConnectorProfileProperties

	// The connector-specific properties required by Dynatrace.
	Dynatrace *DynatraceConnectorProfileProperties

	// The connector-specific properties required Google Analytics.
	GoogleAnalytics *GoogleAnalyticsConnectorProfileProperties

	// The connector-specific properties required by Infor Nexus.
	InforNexus *InforNexusConnectorProfileProperties

	// The connector-specific properties required by Marketo.
	Marketo *MarketoConnectorProfileProperties

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

	// The connector-specific properties required by Salesforce.
	Salesforce *SalesforceConnectorProfileProperties

	// The connector-specific properties required by serviceNow.
	ServiceNow *ServiceNowConnectorProfileProperties

	// The connector-specific properties required by Singular.
	Singular *SingularConnectorProfileProperties

	// The connector-specific properties required by Slack.
	Slack *SlackConnectorProfileProperties

	// The connector-specific properties required by Snowflake.
	Snowflake *SnowflakeConnectorProfileProperties

	// The connector-specific properties required by Trend Micro.
	Trendmicro *TrendmicroConnectorProfileProperties

	// The connector-specific properties required by Veeva.
	Veeva *VeevaConnectorProfileProperties

	// The connector-specific properties required by Zendesk.
	Zendesk *ZendeskConnectorProfileProperties
}

The connector-specific profile properties required by each connector.

type ConnectorServerException 

type ConnectorServerException struct {
	Message *string
}

An error occurred when retrieving data from the connector endpoint.

func (*ConnectorServerException) Error 

func (e *ConnectorServerException) Error() string

func (*ConnectorServerException) ErrorCode 

func (e *ConnectorServerException) ErrorCode() string

func (*ConnectorServerException) ErrorFault 

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

func (*ConnectorServerException) ErrorMessage 

func (e *ConnectorServerException) ErrorMessage() string

type ConnectorType 

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

Enum values for ConnectorType

func (ConnectorType) Values 

func (ConnectorType) Values() []ConnectorType

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

type DataPullMode 

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

Enum values for DataPullMode

func (DataPullMode) Values 

func (DataPullMode) Values() []DataPullMode

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

type DatadogConnectorOperator 

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

Enum values for DatadogConnectorOperator

func (DatadogConnectorOperator) Values 

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
}

The connector-specific credentials required by Datadog.

type DatadogConnectorProfileProperties 

type DatadogConnectorProfileProperties struct {

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

The connector-specific profile properties required by Datadog.

type DatadogMetadata 

type DatadogMetadata struct {
}

The connector metadata specific to Datadog.

type DatadogSourceProperties 

type DatadogSourceProperties struct {

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

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

type DestinationConnectorProperties 

type DestinationConnectorProperties struct {

	// The properties required to query Amazon EventBridge.
	EventBridge *EventBridgeDestinationProperties

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

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

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

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

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

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

type DestinationFieldProperties 

type DestinationFieldProperties struct {

	// Specifies if the destination field can be created by the current user.
	IsCreatable bool

	// Specifies if the destination field can have a null value.
	IsNullable bool

	// Specifies whether the field can be updated during an UPDATE or UPSERT write
	// operation.
	IsUpdatable bool

	// Specifies if the flow run can either insert new rows in the destination field if
	// they do not already exist, or update them if they do.
	IsUpsertable bool

	// A list of supported write operations. For each write operation listed, this
	// field can be used in idFieldNames when that write operation is present as a
	// destination option.
	SupportedWriteOperations []WriteOperationType
}

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

type DestinationFlowConfig 

type DestinationFlowConfig struct {

	// The type of connector, such as Salesforce, Amplitude, and so on.
	//
	// This member is required.
	ConnectorType ConnectorType

	// This stores the information that is required to query a particular connector.
	//
	// This member is required.
	DestinationConnectorProperties *DestinationConnectorProperties

	// The name of the connector profile. This name must be unique for each connector
	// profile in the AWS account.
	ConnectorProfileName *string
}

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

type DynatraceConnectorOperator 

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

Enum values for DynatraceConnectorOperator

func (DynatraceConnectorOperator) Values 

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
}

The connector-specific profile credentials required by Dynatrace.

type DynatraceConnectorProfileProperties 

type DynatraceConnectorProfileProperties struct {

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

The connector-specific profile properties required by Dynatrace.

type DynatraceMetadata 

type DynatraceMetadata struct {
}

The connector metadata specific to Dynatrace.

type DynatraceSourceProperties 

type DynatraceSourceProperties struct {

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

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

type ErrorHandlingConfig 

type ErrorHandlingConfig struct {

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

	// Specifies the Amazon S3 bucket prefix.
	BucketPrefix *string

	// Specifies if the flow should fail after the first instance of a failure when
	// attempting to place data in the destination.
	FailOnFirstDestinationError bool
}

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

type ErrorInfo 

type ErrorInfo struct {

	// Specifies the error message that appears if a flow fails.
	ExecutionMessage *string

	// Specifies the failure count for the attempted flow.
	PutFailuresCount *int64
}

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

type EventBridgeDestinationProperties 

type EventBridgeDestinationProperties struct {

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

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

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

type EventBridgeMetadata 

type EventBridgeMetadata struct {
}

The connector metadata specific to Amazon EventBridge.

type ExecutionDetails 

type ExecutionDetails struct {

	// Describes the details of the most recent flow run.
	MostRecentExecutionMessage *string

	// Specifies the status of the most recent flow run.
	MostRecentExecutionStatus ExecutionStatus

	// Specifies the time of the most recent flow run.
	MostRecentExecutionTime *time.Time
}

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

type ExecutionRecord 

type ExecutionRecord struct {

	// Specifies the identifier of the given flow run.
	ExecutionId *string

	// Describes the result of the given flow run.
	ExecutionResult *ExecutionResult

	// Specifies the flow run status and whether it is in progress, has completed
	// successfully, or has failed.
	ExecutionStatus ExecutionStatus

	// Specifies the time of the most recent update.
	LastUpdatedAt *time.Time

	// Specifies the start time of the flow run.
	StartedAt *time.Time
}

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

type ExecutionResult 

type ExecutionResult struct {

	// The total number of bytes processed by the flow run.
	BytesProcessed *int64

	// The total number of bytes written as a result of the flow run.
	BytesWritten *int64

	// Provides any error message information related to the flow run.
	ErrorInfo *ErrorInfo

	// The number of records processed in the flow run.
	RecordsProcessed *int64
}

Specifies the end result of the flow run.

type ExecutionStatus 

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

Enum values for ExecutionStatus

func (ExecutionStatus) Values 

func (ExecutionStatus) Values() []ExecutionStatus

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

type FieldTypeDetails 

type FieldTypeDetails struct {

	// The type of field, such as string, integer, date, and so on.
	//
	// This member is required.
	FieldType *string

	// The list of operators supported by a field.
	//
	// This member is required.
	FilterOperators []Operator

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

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

type FileType 

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

Enum values for FileType

func (FileType) Values 

func (FileType) Values() []FileType

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

type FlowDefinition 

type FlowDefinition struct {

	// Specifies when the flow was created.
	CreatedAt *time.Time

	// The ARN of the user who created the flow.
	CreatedBy *string

	// A user-entered description of the flow.
	Description *string

	// Specifies the destination connector type, such as Salesforce, Amazon S3,
	// Amplitude, and so on.
	DestinationConnectorType ConnectorType

	// The flow's Amazon Resource Name (ARN).
	FlowArn *string

	// The specified name of the flow. Spaces are not allowed. Use underscores (_) or
	// hyphens (-) only.
	FlowName *string

	// Indicates the current status of the flow.
	FlowStatus FlowStatus

	// Describes the details of the most recent flow run.
	LastRunExecutionDetails *ExecutionDetails

	// Specifies when the flow was last updated.
	LastUpdatedAt *time.Time

	// Specifies the account user name that most recently updated the flow.
	LastUpdatedBy *string

	// Specifies the source connector type, such as Salesforce, Amazon S3, Amplitude,
	// and so on.
	SourceConnectorType ConnectorType

	// The tags used to organize, track, or control access for your flow.
	Tags map[string]string

	// Specifies the type of flow trigger. This can be OnDemand, Scheduled, or Event.
	TriggerType TriggerType
}

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

type FlowStatus 

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

Enum values for FlowStatus

func (FlowStatus) Values 

func (FlowStatus) Values() []FlowStatus

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

type GoogleAnalyticsConnectorOperator 

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

Enum values for GoogleAnalyticsConnectorOperator

func (GoogleAnalyticsConnectorOperator) Values 

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
}

The connector-specific profile credentials required by Google Analytics.

type GoogleAnalyticsConnectorProfileProperties 

type GoogleAnalyticsConnectorProfileProperties struct {
}

The connector-specific profile properties required by Google Analytics.

type GoogleAnalyticsMetadata 

type GoogleAnalyticsMetadata struct {

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

The connector metadata specific to Google Analytics.

type GoogleAnalyticsSourceProperties 

type GoogleAnalyticsSourceProperties struct {

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

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

type IncrementalPullConfig 

type IncrementalPullConfig struct {

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

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

type InforNexusConnectorOperator 

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

Enum values for InforNexusConnectorOperator

func (InforNexusConnectorOperator) Values 

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
}

The connector-specific profile credentials required by Infor Nexus.

type InforNexusConnectorProfileProperties 

type InforNexusConnectorProfileProperties struct {

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

The connector-specific profile properties required by Infor Nexus.

type InforNexusMetadata 

type InforNexusMetadata struct {
}

The connector metadata specific to Infor Nexus.

type InforNexusSourceProperties 

type InforNexusSourceProperties struct {

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

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

type InternalServerException 

type InternalServerException struct {
	Message *string
}

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

func (*InternalServerException) Error 

func (e *InternalServerException) Error() string

func (*InternalServerException) ErrorCode 

func (e *InternalServerException) ErrorCode() string

func (*InternalServerException) ErrorFault 

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

func (*InternalServerException) ErrorMessage 

func (e *InternalServerException) ErrorMessage() string

type MarketoConnectorOperator 

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

Enum values for MarketoConnectorOperator

func (MarketoConnectorOperator) Values 

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
}

The connector-specific profile credentials required by Marketo.

type MarketoConnectorProfileProperties 

type MarketoConnectorProfileProperties struct {

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

The connector-specific profile properties required when using Marketo.

type MarketoMetadata 

type MarketoMetadata struct {
}

The connector metadata specific to Marketo.

type MarketoSourceProperties 

type MarketoSourceProperties struct {

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

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

type Operator 

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

Enum values for Operator

func (Operator) Values 

func (Operator) Values() []Operator

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

type OperatorPropertiesKeys 

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

Enum values for OperatorPropertiesKeys

func (OperatorPropertiesKeys) Values 

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 PrefixConfig 

type PrefixConfig struct {

	// Determines the format of the prefix, and whether it applies to the file name,
	// file path, or both.
	PrefixFormat PrefixFormat

	// Determines the level of granularity that's included in the prefix.
	PrefixType PrefixType
}

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

type PrefixFormat 

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

Enum values for PrefixFormat

func (PrefixFormat) Values 

func (PrefixFormat) Values() []PrefixFormat

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

type PrefixType 

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

Enum values for PrefixType

func (PrefixType) Values 

func (PrefixType) Values() []PrefixType

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

type RedshiftConnectorProfileCredentials 

type RedshiftConnectorProfileCredentials struct {

	// The password that corresponds to the user name.
	//
	// This member is required.
	Password *string

	// The name of the user.
	//
	// This member is required.
	Username *string
}

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

type RedshiftConnectorProfileProperties 

type RedshiftConnectorProfileProperties struct {

	// A name for the associated Amazon S3 bucket.
	//
	// This member is required.
	BucketName *string

	// The JDBC URL of the Amazon Redshift cluster.
	//
	// This member is required.
	DatabaseUrl *string

	// The Amazon Resource Name (ARN) of the IAM role.
	//
	// This member is required.
	RoleArn *string

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

The connector-specific profile properties when using Amazon Redshift.

type RedshiftDestinationProperties 

type RedshiftDestinationProperties struct {

	// The intermediate bucket that Amazon AppFlow uses when moving data into Amazon
	// Redshift.
	//
	// This member is required.
	IntermediateBucketName *string

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

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

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

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

type RedshiftMetadata 

type RedshiftMetadata struct {
}

The connector metadata specific to Amazon Redshift.

type ResourceNotFoundException 

type ResourceNotFoundException struct {
	Message *string
}

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

func (*ResourceNotFoundException) Error 

func (e *ResourceNotFoundException) Error() string

func (*ResourceNotFoundException) ErrorCode 

func (e *ResourceNotFoundException) ErrorCode() string

func (*ResourceNotFoundException) ErrorFault 

func (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
}

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

type S3Metadata 

type S3Metadata struct {
}

The connector metadata specific to Amazon S3.

type S3OutputFormatConfig 

type S3OutputFormatConfig struct {

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

	// Indicates the file type that Amazon AppFlow places in the Amazon S3 bucket.
	FileType FileType

	// Determines the prefix that Amazon AppFlow applies to the folder name in the
	// Amazon S3 bucket. You can name folders according to the flow frequency and date.
	PrefixConfig *PrefixConfig
}

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

type S3SourceProperties 

type S3SourceProperties struct {

	// The Amazon S3 bucket name where the source files are stored.
	//
	// This member is required.
	BucketName *string

	// The object key for the Amazon S3 bucket in which the source files are stored.
	BucketPrefix *string
}

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

type SalesforceConnectorOperator 

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

Enum values for SalesforceConnectorOperator

func (SalesforceConnectorOperator) Values 

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

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

	// The credentials used to acquire new access tokens.
	RefreshToken *string
}

The connector-specific profile credentials required when using Salesforce.

type SalesforceConnectorProfileProperties 

type SalesforceConnectorProfileProperties struct {

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

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

The connector-specific profile properties required when using Salesforce.

type SalesforceDestinationProperties 

type SalesforceDestinationProperties struct {

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

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

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

	// This specifies the type of write operation to be performed in Salesforce. When
	// the value is UPSERT, then idFieldNames is required.
	WriteOperationType WriteOperationType
}

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

type SalesforceMetadata 

type SalesforceMetadata struct {

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

The connector metadata specific to Salesforce.

type SalesforceSourceProperties 

type SalesforceSourceProperties struct {

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

	// The flag that enables dynamic fetching of new (recently added) fields in the
	// Salesforce objects while running a flow.
	EnableDynamicFieldUpdate bool

	// Indicates whether Amazon AppFlow includes deleted files in the flow run.
	IncludeDeletedRecords bool
}

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

type ScheduleFrequencyType 

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

Enum values for ScheduleFrequencyType

func (ScheduleFrequencyType) Values 

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 scheduled end time for a schedule-triggered flow.
	ScheduleEndTime *time.Time

	// Specifies the scheduled start time for a schedule-triggered flow.
	ScheduleStartTime *time.Time

	// Specifies the time zone used when referring to the date and time of a
	// scheduled-triggered flow.
	Timezone *string
}

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

type ServiceNowConnectorOperator 

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

Enum values for ServiceNowConnectorOperator

func (ServiceNowConnectorOperator) Values 

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 password that corresponds to the user name.
	//
	// This member is required.
	Password *string

	// The name of the user.
	//
	// This member is required.
	Username *string
}

The connector-specific profile credentials required when using ServiceNow.

type ServiceNowConnectorProfileProperties 

type ServiceNowConnectorProfileProperties struct {

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

The connector-specific profile properties required when using ServiceNow.

type ServiceNowMetadata 

type ServiceNowMetadata struct {
}

The connector metadata specific to ServiceNow.

type ServiceNowSourceProperties 

type ServiceNowSourceProperties struct {

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

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

type ServiceQuotaExceededException 

type ServiceQuotaExceededException struct {
	Message *string
}

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

func (*ServiceQuotaExceededException) Error 

func (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
}

The connector-specific profile credentials required when using Singular.

type SingularConnectorProfileProperties 

type SingularConnectorProfileProperties struct {
}

The connector-specific profile properties required when using Singular.

type SingularMetadata 

type SingularMetadata struct {
}

The connector metadata specific to Singular.

type SingularSourceProperties 

type SingularSourceProperties struct {

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

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

type SlackConnectorOperator 

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

Enum values for SlackConnectorOperator

func (SlackConnectorOperator) Values 

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
}

The connector-specific profile credentials required when using Slack.

type SlackConnectorProfileProperties 

type SlackConnectorProfileProperties struct {

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

The connector-specific profile properties required when using Slack.

type SlackMetadata 

type SlackMetadata struct {

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

The connector metadata specific to Slack.

type SlackSourceProperties 

type SlackSourceProperties struct {

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

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

type SnowflakeConnectorProfileCredentials 

type SnowflakeConnectorProfileCredentials struct {

	// The password that corresponds to the user name.
	//
	// This member is required.
	Password *string

	// The name of the user.
	//
	// This member is required.
	Username *string
}

The connector-specific profile credentials required when using Snowflake.

type SnowflakeConnectorProfileProperties 

type SnowflakeConnectorProfileProperties struct {

	// The name of the Amazon S3 bucket associated with Snowflake.
	//
	// This member is required.
	BucketName *string

	// The name of the Amazon S3 stage that was created while setting up an Amazon S3
	// stage in the Snowflake account. This is written in the following format: <
	// Database>< Schema>.
	//
	// This member is required.
	Stage *string

	// The name of the Snowflake warehouse.
	//
	// This member is required.
	Warehouse *string

	// The name of the account.
	AccountName *string

	// The bucket path that refers to the Amazon S3 bucket associated with Snowflake.
	BucketPrefix *string

	// The Snowflake Private Link service name to be used for private data transfers.
	PrivateLinkServiceName *string

	// The AWS Region of the Snowflake account.
	Region *string
}

The connector-specific profile properties required when using Snowflake.

type SnowflakeDestinationProperties 

type SnowflakeDestinationProperties struct {

	// The intermediate bucket that Amazon AppFlow uses when moving data into
	// Snowflake.
	//
	// This member is required.
	IntermediateBucketName *string

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

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

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

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

type SnowflakeMetadata 

type SnowflakeMetadata struct {

	// Specifies the supported AWS Regions when using Snowflake.
	SupportedRegions []string
}

The connector metadata specific to Snowflake.

type SourceConnectorProperties 

type SourceConnectorProperties struct {

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

	// Specifies the information that is required for querying Datadog.
	Datadog *DatadogSourceProperties

	// Specifies the information that is required for querying Dynatrace.
	Dynatrace *DynatraceSourceProperties

	// Specifies the information that is required for querying Google Analytics.
	GoogleAnalytics *GoogleAnalyticsSourceProperties

	// Specifies the information that is required for querying Infor Nexus.
	InforNexus *InforNexusSourceProperties

	// Specifies the information that is required for querying Marketo.
	Marketo *MarketoSourceProperties

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

	// Specifies the information that is required for querying Salesforce.
	Salesforce *SalesforceSourceProperties

	// Specifies the information that is required for querying ServiceNow.
	ServiceNow *ServiceNowSourceProperties

	// Specifies the information that is required for querying Singular.
	Singular *SingularSourceProperties

	// Specifies the information that is required for querying Slack.
	Slack *SlackSourceProperties

	// Specifies the information that is required for querying Trend Micro.
	Trendmicro *TrendmicroSourceProperties

	// Specifies the information that is required for querying Veeva.
	Veeva *VeevaSourceProperties

	// Specifies the information that is required for querying Zendesk.
	Zendesk *ZendeskSourceProperties
}

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

type SourceFieldProperties 

type SourceFieldProperties struct {

	// Indicates if the field can be queried.
	IsQueryable bool

	// Indicates whether the field can be returned in a search result.
	IsRetrievable bool
}

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

type SourceFlowConfig 

type SourceFlowConfig struct {

	// The type of connector, such as Salesforce, Amplitude, and so on.
	//
	// This member is required.
	ConnectorType ConnectorType

	// Specifies the information that is required to query a particular source
	// connector.
	//
	// This member is required.
	SourceConnectorProperties *SourceConnectorProperties

	// The name of the connector profile. This name must be unique for each connector
	// profile in the AWS account.
	ConnectorProfileName *string

	// Defines the configuration for a scheduled incremental data pull. If a valid
	// configuration is provided, the fields specified in the configuration are used
	// when querying for the incremental data pull.
	IncrementalPullConfig *IncrementalPullConfig
}

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

type SupportedFieldTypeDetails 

type SupportedFieldTypeDetails struct {

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

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

type Task 

type Task struct {

	// The source fields to which a particular task is applied.
	//
	// This member is required.
	SourceFields []string

	// Specifies the particular task implementation that Amazon AppFlow performs.
	//
	// This member is required.
	TaskType TaskType

	// The operation to be performed on the provided source fields.
	ConnectorOperator *ConnectorOperator

	// A field in a destination connector, or a field value against which Amazon
	// AppFlow validates a source field.
	DestinationField *string

	// A map used to store task-related information. The execution service looks for
	// particular information based on the TaskType.
	TaskProperties map[string]string
}

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

type TaskType 

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

Enum values for TaskType

func (TaskType) Values 

func (TaskType) Values() []TaskType

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

type TrendmicroConnectorOperator 

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

Enum values for TrendmicroConnectorOperator

func (TrendmicroConnectorOperator) Values 

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
}

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

type TrendmicroConnectorProfileProperties 

type TrendmicroConnectorProfileProperties struct {
}

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

type TrendmicroMetadata 

type TrendmicroMetadata struct {
}

The connector metadata specific to Trend Micro.

type TrendmicroSourceProperties 

type TrendmicroSourceProperties struct {

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

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

type TriggerConfig 

type TriggerConfig struct {

	// Specifies the type of flow trigger. This can be OnDemand, Scheduled, or Event.
	//
	// This member is required.
	TriggerType TriggerType

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

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

type TriggerProperties 

type TriggerProperties struct {

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

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

type TriggerType 

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

Enum values for TriggerType

func (TriggerType) Values 

func (TriggerType) Values() []TriggerType

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

type UnsupportedOperationException 

type UnsupportedOperationException struct {
	Message *string
}

The requested operation is not supported for the current flow.

func (*UnsupportedOperationException) Error 

func (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 added in v0.3.0 

type UpsolverDestinationProperties struct {

	// The Upsolver Amazon S3 bucket name in which Amazon AppFlow places the
	// transferred data.
	//
	// This member is required.
	BucketName *string

	// The configuration that determines how data is formatted when Upsolver is used as
	// the flow destination.
	//
	// This member is required.
	S3OutputFormatConfig *UpsolverS3OutputFormatConfig

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

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

type UpsolverMetadata added in v0.3.0 

type UpsolverMetadata struct {
}

The connector metadata specific to Upsolver.

type UpsolverS3OutputFormatConfig added in v0.3.0 

type UpsolverS3OutputFormatConfig struct {

	// Determines the prefix that Amazon AppFlow applies to the destination folder
	// name. You can name your destination folders according to the flow frequency and
	// date.
	//
	// This member is required.
	PrefixConfig *PrefixConfig

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

	// Indicates the file type that Amazon AppFlow places in the Upsolver Amazon S3
	// bucket.
	FileType FileType
}

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

type ValidationException 

type ValidationException struct {
	Message *string
}

The request has invalid or missing parameters.

func (*ValidationException) Error 

func (e *ValidationException) Error() string

func (*ValidationException) ErrorCode 

func (e *ValidationException) ErrorCode() string

func (*ValidationException) ErrorFault 

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

func (*ValidationException) ErrorMessage 

func (e *ValidationException) ErrorMessage() string

type VeevaConnectorOperator 

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

Enum values for VeevaConnectorOperator

func (VeevaConnectorOperator) Values 

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
}

The connector-specific profile credentials required when using Veeva.

type VeevaConnectorProfileProperties 

type VeevaConnectorProfileProperties struct {

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

The connector-specific profile properties required when using Veeva.

type VeevaMetadata 

type VeevaMetadata struct {
}

The connector metadata specific to Veeva.

type VeevaSourceProperties 

type VeevaSourceProperties struct {

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

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

type WriteOperationType 

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

Enum values for WriteOperationType

func (WriteOperationType) Values 

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
}

The connector-specific profile credentials required when using Zendesk.

type ZendeskConnectorProfileProperties 

type ZendeskConnectorProfileProperties struct {

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

The connector-specific profile properties required when using Zendesk.

type ZendeskMetadata 

type ZendeskMetadata struct {

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

The connector metadata specific to Zendesk.

type ZendeskSourceProperties 

type ZendeskSourceProperties struct {

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

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

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.