Documentation

Overview

    Package appflow provides the API client, operations, and parameter types for Amazon Appflow.

    Welcome to the Amazon AppFlow API reference. This guide is for developers who need detailed information about the Amazon AppFlow API operations, data types, and errors. Amazon AppFlow is a fully managed integration service that enables you to securely transfer data between software as a service (SaaS) applications like Salesforce, Marketo, Slack, and ServiceNow, and AWS services like Amazon S3 and Amazon Redshift. Use the following links to get started on the Amazon AppFlow API:

    * Actions (https://docs.aws.amazon.com/appflow/1.0/APIReference/API_Operations.html): An alphabetical list of all Amazon AppFlow API operations.

    * Data types (https://docs.aws.amazon.com/appflow/1.0/APIReference/API_Types.html): An alphabetical list of all Amazon AppFlow data types.

    * Common parameters (https://docs.aws.amazon.com/appflow/1.0/APIReference/CommonParameters.html): Parameters that all Query operations can use.

    * Common errors (https://docs.aws.amazon.com/appflow/1.0/APIReference/CommonErrors.html): Client and server errors that all operations can return.

    If you're new to Amazon AppFlow, we recommend that you review the Amazon AppFlow User Guide (https://docs.aws.amazon.com/appflow/latest/userguide/what-is-appflow.html). Amazon AppFlow API users can use vendor-specific mechanisms for OAuth, and include applicable OAuth attributes (such as auth-code and redirecturi) with the connector-specific ConnectorProfileProperties when creating a new connector profile using Amazon AppFlow API operations. For example, Salesforce users can refer to the Authorize Apps with OAuth (https://help.salesforce.com/articleView?id=remoteaccess_authenticate.htm) documentation.

    Index

    Constants

    View Source
    const ServiceAPIVersion = "2020-08-23"
    View Source
    const ServiceID = "Appflow"

    Variables

    This section is empty.

    Functions

    func NewDefaultEndpointResolver

    func NewDefaultEndpointResolver() *internalendpoints.Resolver

      NewDefaultEndpointResolver constructs a new service endpoint resolver

      func WithAPIOptions

      func WithAPIOptions(optFns ...func(*middleware.Stack) error) func(*Options)

        WithAPIOptions returns a functional option for setting the Client's APIOptions option.

        func WithEndpointResolver

        func WithEndpointResolver(v EndpointResolver) func(*Options)

          WithEndpointResolver returns a functional option for setting the Client's EndpointResolver option.

          Types

          type Client

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

            Client provides the API client to make operations call for Amazon Appflow.

            func New

            func New(options Options, optFns ...func(*Options)) *Client

              New returns an initialized Client based on the functional options. Provide additional functional options to further configure the behavior of the client, such as changing the client's endpoint or adding custom middleware behavior.

              func NewFromConfig

              func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client

                NewFromConfig returns a new client from the provided config.

                func (*Client) CreateConnectorProfile

                func (c *Client) CreateConnectorProfile(ctx context.Context, params *CreateConnectorProfileInput, optFns ...func(*Options)) (*CreateConnectorProfileOutput, error)

                  Creates a new connector profile associated with your AWS account. There is a soft quota of 100 connector profiles per AWS account. If you need more connector profiles than this quota allows, you can submit a request to the Amazon AppFlow team through the Amazon AppFlow support channel.

                  func (*Client) CreateFlow

                  func (c *Client) CreateFlow(ctx context.Context, params *CreateFlowInput, optFns ...func(*Options)) (*CreateFlowOutput, error)

                    Enables your application to create a new flow using Amazon AppFlow. You must create a connector profile before calling this API. Please note that the Request Syntax below shows syntax for multiple destinations, however, you can only transfer data to one item in this list at a time. Amazon AppFlow does not currently support flows to multiple destinations at once.

                    func (*Client) DeleteConnectorProfile

                    func (c *Client) DeleteConnectorProfile(ctx context.Context, params *DeleteConnectorProfileInput, optFns ...func(*Options)) (*DeleteConnectorProfileOutput, error)

                      Enables you to delete an existing connector profile.

                      func (*Client) DeleteFlow

                      func (c *Client) DeleteFlow(ctx context.Context, params *DeleteFlowInput, optFns ...func(*Options)) (*DeleteFlowOutput, error)

                        Enables your application to delete an existing flow. Before deleting the flow, Amazon AppFlow validates the request by checking the flow configuration and status. You can delete flows one at a time.

                        func (*Client) DescribeConnectorEntity

                        func (c *Client) DescribeConnectorEntity(ctx context.Context, params *DescribeConnectorEntityInput, optFns ...func(*Options)) (*DescribeConnectorEntityOutput, error)

                          Provides details regarding the entity used with the connector, with a description of the data model for each entity.

                          func (*Client) DescribeConnectorProfiles

                          func (c *Client) DescribeConnectorProfiles(ctx context.Context, params *DescribeConnectorProfilesInput, optFns ...func(*Options)) (*DescribeConnectorProfilesOutput, error)

                            Returns a list of connector-profile details matching the provided connector-profile names and connector-types. Both input lists are optional, and you can use them to filter the result. If no names or connector-types are provided, returns all connector profiles in a paginated form. If there is no match, this operation returns an empty list.

                            func (*Client) DescribeConnectors

                            func (c *Client) DescribeConnectors(ctx context.Context, params *DescribeConnectorsInput, optFns ...func(*Options)) (*DescribeConnectorsOutput, error)

                              Describes the connectors vended by Amazon AppFlow for specified connector types. If you don't specify a connector type, this operation describes all connectors vended by Amazon AppFlow. If there are more connectors than can be returned in one page, the response contains a nextToken object, which can be be passed in to the next call to the DescribeConnectors API operation to retrieve the next page.

                              func (*Client) DescribeFlow

                              func (c *Client) DescribeFlow(ctx context.Context, params *DescribeFlowInput, optFns ...func(*Options)) (*DescribeFlowOutput, error)

                                Provides a description of the specified flow.

                                func (*Client) DescribeFlowExecutionRecords

                                func (c *Client) DescribeFlowExecutionRecords(ctx context.Context, params *DescribeFlowExecutionRecordsInput, optFns ...func(*Options)) (*DescribeFlowExecutionRecordsOutput, error)

                                  Fetches the execution history of the flow.

                                  func (*Client) ListConnectorEntities

                                  func (c *Client) ListConnectorEntities(ctx context.Context, params *ListConnectorEntitiesInput, optFns ...func(*Options)) (*ListConnectorEntitiesOutput, error)

                                    Returns the list of available connector entities supported by Amazon AppFlow. For example, you can query Salesforce for Account and Opportunity entities, or query ServiceNow for the Incident entity.

                                    func (*Client) ListFlows

                                    func (c *Client) ListFlows(ctx context.Context, params *ListFlowsInput, optFns ...func(*Options)) (*ListFlowsOutput, error)

                                      Lists all of the flows associated with your account.

                                      func (*Client) ListTagsForResource

                                      func (c *Client) ListTagsForResource(ctx context.Context, params *ListTagsForResourceInput, optFns ...func(*Options)) (*ListTagsForResourceOutput, error)

                                        Retrieves the tags that are associated with a specified flow.

                                        func (*Client) StartFlow

                                        func (c *Client) StartFlow(ctx context.Context, params *StartFlowInput, optFns ...func(*Options)) (*StartFlowOutput, error)

                                          Activates an existing flow. For on-demand flows, this operation runs the flow immediately. For schedule and event-triggered flows, this operation activates the flow.

                                          func (*Client) StopFlow

                                          func (c *Client) StopFlow(ctx context.Context, params *StopFlowInput, optFns ...func(*Options)) (*StopFlowOutput, error)

                                            Deactivates the existing flow. For on-demand flows, this operation returns an unsupportedOperationException error message. For schedule and event-triggered flows, this operation deactivates the flow.

                                            func (*Client) TagResource

                                            func (c *Client) TagResource(ctx context.Context, params *TagResourceInput, optFns ...func(*Options)) (*TagResourceOutput, error)

                                              Applies a tag to the specified flow.

                                              func (*Client) UntagResource

                                              func (c *Client) UntagResource(ctx context.Context, params *UntagResourceInput, optFns ...func(*Options)) (*UntagResourceOutput, error)

                                                Removes a tag from the specified flow.

                                                func (*Client) UpdateConnectorProfile

                                                func (c *Client) UpdateConnectorProfile(ctx context.Context, params *UpdateConnectorProfileInput, optFns ...func(*Options)) (*UpdateConnectorProfileOutput, error)

                                                  Updates a given connector profile associated with your account.

                                                  func (*Client) UpdateFlow

                                                  func (c *Client) UpdateFlow(ctx context.Context, params *UpdateFlowInput, optFns ...func(*Options)) (*UpdateFlowOutput, error)

                                                    Updates an existing flow.

                                                    type CreateConnectorProfileInput

                                                    type CreateConnectorProfileInput struct {
                                                    
                                                    	// Indicates the connection mode and specifies whether it is public or private.
                                                    	// Private flows use AWS PrivateLink to route data over AWS infrastructure without
                                                    	// exposing it to the public internet.
                                                    	//
                                                    	// This member is required.
                                                    	ConnectionMode types.ConnectionMode
                                                    
                                                    	// Defines the connector-specific configuration and credentials.
                                                    	//
                                                    	// This member is required.
                                                    	ConnectorProfileConfig *types.ConnectorProfileConfig
                                                    
                                                    	// The name of the connector profile. The name is unique for each ConnectorProfile
                                                    	// in your AWS account.
                                                    	//
                                                    	// This member is required.
                                                    	ConnectorProfileName *string
                                                    
                                                    	// The type of connector, such as Salesforce, Amplitude, and so on.
                                                    	//
                                                    	// This member is required.
                                                    	ConnectorType types.ConnectorType
                                                    
                                                    	// The ARN (Amazon Resource Name) of the Key Management Service (KMS) key you
                                                    	// provide for encryption. This is required if you do not want to use the Amazon
                                                    	// AppFlow-managed KMS key. If you don't provide anything here, Amazon AppFlow uses
                                                    	// the Amazon AppFlow-managed KMS key.
                                                    	KmsArn *string
                                                    }

                                                    type CreateConnectorProfileOutput

                                                    type CreateConnectorProfileOutput struct {
                                                    
                                                    	// The Amazon Resource Name (ARN) of the connector profile.
                                                    	ConnectorProfileArn *string
                                                    
                                                    	// Metadata pertaining to the operation's result.
                                                    	ResultMetadata middleware.Metadata
                                                    }

                                                    type CreateFlowInput

                                                    type CreateFlowInput struct {
                                                    
                                                    	// The configuration that controls how Amazon AppFlow places data in the
                                                    	// destination connector.
                                                    	//
                                                    	// This member is required.
                                                    	DestinationFlowConfigList []types.DestinationFlowConfig
                                                    
                                                    	// The specified name of the flow. Spaces are not allowed. Use underscores (_) or
                                                    	// hyphens (-) only.
                                                    	//
                                                    	// This member is required.
                                                    	FlowName *string
                                                    
                                                    	// The configuration that controls how Amazon AppFlow retrieves data from the
                                                    	// source connector.
                                                    	//
                                                    	// This member is required.
                                                    	SourceFlowConfig *types.SourceFlowConfig
                                                    
                                                    	// A list of tasks that Amazon AppFlow performs while transferring the data in the
                                                    	// flow run.
                                                    	//
                                                    	// This member is required.
                                                    	Tasks []types.Task
                                                    
                                                    	// The trigger settings that determine how and when the flow runs.
                                                    	//
                                                    	// This member is required.
                                                    	TriggerConfig *types.TriggerConfig
                                                    
                                                    	// A description of the flow you want to create.
                                                    	Description *string
                                                    
                                                    	// The ARN (Amazon Resource Name) of the Key Management Service (KMS) key you
                                                    	// provide for encryption. This is required if you do not want to use the Amazon
                                                    	// AppFlow-managed KMS key. If you don't provide anything here, Amazon AppFlow uses
                                                    	// the Amazon AppFlow-managed KMS key.
                                                    	KmsArn *string
                                                    
                                                    	// The tags used to organize, track, or control access for your flow.
                                                    	Tags map[string]string
                                                    }

                                                    type CreateFlowOutput

                                                    type CreateFlowOutput struct {
                                                    
                                                    	// The flow's Amazon Resource Name (ARN).
                                                    	FlowArn *string
                                                    
                                                    	// Indicates the current status of the flow.
                                                    	FlowStatus types.FlowStatus
                                                    
                                                    	// Metadata pertaining to the operation's result.
                                                    	ResultMetadata middleware.Metadata
                                                    }

                                                    type DeleteConnectorProfileInput

                                                    type DeleteConnectorProfileInput struct {
                                                    
                                                    	// The name of the connector profile. The name is unique for each ConnectorProfile
                                                    	// in your account.
                                                    	//
                                                    	// This member is required.
                                                    	ConnectorProfileName *string
                                                    
                                                    	// Indicates whether Amazon AppFlow should delete the profile, even if it is
                                                    	// currently in use in one or more flows.
                                                    	ForceDelete bool
                                                    }

                                                    type DeleteConnectorProfileOutput

                                                    type DeleteConnectorProfileOutput struct {
                                                    	// Metadata pertaining to the operation's result.
                                                    	ResultMetadata middleware.Metadata
                                                    }

                                                    type DeleteFlowInput

                                                    type DeleteFlowInput struct {
                                                    
                                                    	// The specified name of the flow. Spaces are not allowed. Use underscores (_) or
                                                    	// hyphens (-) only.
                                                    	//
                                                    	// This member is required.
                                                    	FlowName *string
                                                    
                                                    	// Indicates whether Amazon AppFlow should delete the flow, even if it is currently
                                                    	// in use.
                                                    	ForceDelete bool
                                                    }

                                                    type DeleteFlowOutput

                                                    type DeleteFlowOutput struct {
                                                    	// Metadata pertaining to the operation's result.
                                                    	ResultMetadata middleware.Metadata
                                                    }

                                                    type DescribeConnectorEntityInput

                                                    type DescribeConnectorEntityInput struct {
                                                    
                                                    	// The entity name for that connector.
                                                    	//
                                                    	// This member is required.
                                                    	ConnectorEntityName *string
                                                    
                                                    	// The name of the connector profile. The name is unique for each ConnectorProfile
                                                    	// in the AWS account.
                                                    	ConnectorProfileName *string
                                                    
                                                    	// The type of connector application, such as Salesforce, Amplitude, and so on.
                                                    	ConnectorType types.ConnectorType
                                                    }

                                                    type DescribeConnectorEntityOutput

                                                    type DescribeConnectorEntityOutput struct {
                                                    
                                                    	// Describes the fields for that connector entity. For example, for an account
                                                    	// entity, the fields would be account name, account ID, and so on.
                                                    	//
                                                    	// This member is required.
                                                    	ConnectorEntityFields []types.ConnectorEntityField
                                                    
                                                    	// Metadata pertaining to the operation's result.
                                                    	ResultMetadata middleware.Metadata
                                                    }

                                                    type DescribeConnectorProfilesAPIClient

                                                    type DescribeConnectorProfilesAPIClient interface {
                                                    	DescribeConnectorProfiles(context.Context, *DescribeConnectorProfilesInput, ...func(*Options)) (*DescribeConnectorProfilesOutput, error)
                                                    }

                                                      DescribeConnectorProfilesAPIClient is a client that implements the DescribeConnectorProfiles operation.

                                                      type DescribeConnectorProfilesInput

                                                      type DescribeConnectorProfilesInput struct {
                                                      
                                                      	// The name of the connector profile. The name is unique for each ConnectorProfile
                                                      	// in the AWS account.
                                                      	ConnectorProfileNames []string
                                                      
                                                      	// The type of connector, such as Salesforce, Amplitude, and so on.
                                                      	ConnectorType types.ConnectorType
                                                      
                                                      	// Specifies the maximum number of items that should be returned in the result set.
                                                      	// The default for maxResults is 20 (for all paginated API operations).
                                                      	MaxResults *int32
                                                      
                                                      	// The pagination token for the next page of data.
                                                      	NextToken *string
                                                      }

                                                      type DescribeConnectorProfilesOutput

                                                      type DescribeConnectorProfilesOutput struct {
                                                      
                                                      	// Returns information about the connector profiles associated with the flow.
                                                      	ConnectorProfileDetails []types.ConnectorProfile
                                                      
                                                      	// The pagination token for the next page of data. If nextToken=null, this means
                                                      	// that all records have been fetched.
                                                      	NextToken *string
                                                      
                                                      	// Metadata pertaining to the operation's result.
                                                      	ResultMetadata middleware.Metadata
                                                      }

                                                      type DescribeConnectorProfilesPaginator

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

                                                        DescribeConnectorProfilesPaginator is a paginator for DescribeConnectorProfiles

                                                        func NewDescribeConnectorProfilesPaginator

                                                          NewDescribeConnectorProfilesPaginator returns a new DescribeConnectorProfilesPaginator

                                                          func (*DescribeConnectorProfilesPaginator) HasMorePages

                                                          func (p *DescribeConnectorProfilesPaginator) HasMorePages() bool

                                                            HasMorePages returns a boolean indicating whether more pages are available

                                                            func (*DescribeConnectorProfilesPaginator) NextPage

                                                              NextPage retrieves the next DescribeConnectorProfiles page.

                                                              type DescribeConnectorProfilesPaginatorOptions

                                                              type DescribeConnectorProfilesPaginatorOptions struct {
                                                              	// Specifies the maximum number of items that should be returned in the result set.
                                                              	// The default for maxResults is 20 (for all paginated API operations).
                                                              	Limit int32
                                                              
                                                              	// Set to true if pagination should stop if the service returns a pagination token
                                                              	// that matches the most recent token provided to the service.
                                                              	StopOnDuplicateToken bool
                                                              }

                                                                DescribeConnectorProfilesPaginatorOptions is the paginator options for DescribeConnectorProfiles

                                                                type DescribeConnectorsAPIClient

                                                                type DescribeConnectorsAPIClient interface {
                                                                	DescribeConnectors(context.Context, *DescribeConnectorsInput, ...func(*Options)) (*DescribeConnectorsOutput, error)
                                                                }

                                                                  DescribeConnectorsAPIClient is a client that implements the DescribeConnectors operation.

                                                                  type DescribeConnectorsInput

                                                                  type DescribeConnectorsInput struct {
                                                                  
                                                                  	// The type of connector, such as Salesforce, Amplitude, and so on.
                                                                  	ConnectorTypes []types.ConnectorType
                                                                  
                                                                  	// The pagination token for the next page of data.
                                                                  	NextToken *string
                                                                  }

                                                                  type DescribeConnectorsOutput

                                                                  type DescribeConnectorsOutput struct {
                                                                  
                                                                  	// The configuration that is applied to the connectors used in the flow.
                                                                  	ConnectorConfigurations map[string]types.ConnectorConfiguration
                                                                  
                                                                  	// The pagination token for the next page of data.
                                                                  	NextToken *string
                                                                  
                                                                  	// Metadata pertaining to the operation's result.
                                                                  	ResultMetadata middleware.Metadata
                                                                  }

                                                                  type DescribeConnectorsPaginator

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

                                                                    DescribeConnectorsPaginator is a paginator for DescribeConnectors

                                                                    func NewDescribeConnectorsPaginator

                                                                    func NewDescribeConnectorsPaginator(client DescribeConnectorsAPIClient, params *DescribeConnectorsInput, optFns ...func(*DescribeConnectorsPaginatorOptions)) *DescribeConnectorsPaginator

                                                                      NewDescribeConnectorsPaginator returns a new DescribeConnectorsPaginator

                                                                      func (*DescribeConnectorsPaginator) HasMorePages

                                                                      func (p *DescribeConnectorsPaginator) HasMorePages() bool

                                                                        HasMorePages returns a boolean indicating whether more pages are available

                                                                        func (*DescribeConnectorsPaginator) NextPage

                                                                        func (p *DescribeConnectorsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeConnectorsOutput, error)

                                                                          NextPage retrieves the next DescribeConnectors page.

                                                                          type DescribeConnectorsPaginatorOptions

                                                                          type DescribeConnectorsPaginatorOptions struct {
                                                                          	// Set to true if pagination should stop if the service returns a pagination token
                                                                          	// that matches the most recent token provided to the service.
                                                                          	StopOnDuplicateToken bool
                                                                          }

                                                                            DescribeConnectorsPaginatorOptions is the paginator options for DescribeConnectors

                                                                            type DescribeFlowExecutionRecordsAPIClient

                                                                            type DescribeFlowExecutionRecordsAPIClient interface {
                                                                            	DescribeFlowExecutionRecords(context.Context, *DescribeFlowExecutionRecordsInput, ...func(*Options)) (*DescribeFlowExecutionRecordsOutput, error)
                                                                            }

                                                                              DescribeFlowExecutionRecordsAPIClient is a client that implements the DescribeFlowExecutionRecords operation.

                                                                              type DescribeFlowExecutionRecordsInput

                                                                              type DescribeFlowExecutionRecordsInput struct {
                                                                              
                                                                              	// The specified name of the flow. Spaces are not allowed. Use underscores (_) or
                                                                              	// hyphens (-) only.
                                                                              	//
                                                                              	// This member is required.
                                                                              	FlowName *string
                                                                              
                                                                              	// Specifies the maximum number of items that should be returned in the result set.
                                                                              	// The default for maxResults is 20 (for all paginated API operations).
                                                                              	MaxResults *int32
                                                                              
                                                                              	// The pagination token for the next page of data.
                                                                              	NextToken *string
                                                                              }

                                                                              type DescribeFlowExecutionRecordsOutput

                                                                              type DescribeFlowExecutionRecordsOutput struct {
                                                                              
                                                                              	// Returns a list of all instances when this flow was run.
                                                                              	FlowExecutions []types.ExecutionRecord
                                                                              
                                                                              	// The pagination token for the next page of data.
                                                                              	NextToken *string
                                                                              
                                                                              	// Metadata pertaining to the operation's result.
                                                                              	ResultMetadata middleware.Metadata
                                                                              }

                                                                              type DescribeFlowExecutionRecordsPaginator

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

                                                                                DescribeFlowExecutionRecordsPaginator is a paginator for DescribeFlowExecutionRecords

                                                                                func NewDescribeFlowExecutionRecordsPaginator

                                                                                  NewDescribeFlowExecutionRecordsPaginator returns a new DescribeFlowExecutionRecordsPaginator

                                                                                  func (*DescribeFlowExecutionRecordsPaginator) HasMorePages

                                                                                  func (p *DescribeFlowExecutionRecordsPaginator) HasMorePages() bool

                                                                                    HasMorePages returns a boolean indicating whether more pages are available

                                                                                    func (*DescribeFlowExecutionRecordsPaginator) NextPage

                                                                                      NextPage retrieves the next DescribeFlowExecutionRecords page.

                                                                                      type DescribeFlowExecutionRecordsPaginatorOptions

                                                                                      type DescribeFlowExecutionRecordsPaginatorOptions struct {
                                                                                      	// Specifies the maximum number of items that should be returned in the result set.
                                                                                      	// The default for maxResults is 20 (for all paginated API operations).
                                                                                      	Limit int32
                                                                                      
                                                                                      	// Set to true if pagination should stop if the service returns a pagination token
                                                                                      	// that matches the most recent token provided to the service.
                                                                                      	StopOnDuplicateToken bool
                                                                                      }

                                                                                        DescribeFlowExecutionRecordsPaginatorOptions is the paginator options for DescribeFlowExecutionRecords

                                                                                        type DescribeFlowInput

                                                                                        type DescribeFlowInput struct {
                                                                                        
                                                                                        	// The specified name of the flow. Spaces are not allowed. Use underscores (_) or
                                                                                        	// hyphens (-) only.
                                                                                        	//
                                                                                        	// This member is required.
                                                                                        	FlowName *string
                                                                                        }

                                                                                        type DescribeFlowOutput

                                                                                        type DescribeFlowOutput struct {
                                                                                        
                                                                                        	// Specifies when the flow was created.
                                                                                        	CreatedAt *time.Time
                                                                                        
                                                                                        	// The ARN of the user who created the flow.
                                                                                        	CreatedBy *string
                                                                                        
                                                                                        	// A description of the flow.
                                                                                        	Description *string
                                                                                        
                                                                                        	// The configuration that controls how Amazon AppFlow transfers data to the
                                                                                        	// destination connector.
                                                                                        	DestinationFlowConfigList []types.DestinationFlowConfig
                                                                                        
                                                                                        	// 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 types.FlowStatus
                                                                                        
                                                                                        	// Contains an error message if the flow status is in a suspended or error state.
                                                                                        	// This applies only to scheduled or event-triggered flows.
                                                                                        	FlowStatusMessage *string
                                                                                        
                                                                                        	// The ARN (Amazon Resource Name) of the Key Management Service (KMS) key you
                                                                                        	// provide for encryption. This is required if you do not want to use the Amazon
                                                                                        	// AppFlow-managed KMS key. If you don't provide anything here, Amazon AppFlow uses
                                                                                        	// the Amazon AppFlow-managed KMS key.
                                                                                        	KmsArn *string
                                                                                        
                                                                                        	// Describes the details of the most recent flow run.
                                                                                        	LastRunExecutionDetails *types.ExecutionDetails
                                                                                        
                                                                                        	// Specifies when the flow was last updated.
                                                                                        	LastUpdatedAt *time.Time
                                                                                        
                                                                                        	// Specifies the user name of the account that performed the most recent update.
                                                                                        	LastUpdatedBy *string
                                                                                        
                                                                                        	// The configuration that controls how Amazon AppFlow retrieves data from the
                                                                                        	// source connector.
                                                                                        	SourceFlowConfig *types.SourceFlowConfig
                                                                                        
                                                                                        	// The tags used to organize, track, or control access for your flow.
                                                                                        	Tags map[string]string
                                                                                        
                                                                                        	// A list of tasks that Amazon AppFlow performs while transferring the data in the
                                                                                        	// flow run.
                                                                                        	Tasks []types.Task
                                                                                        
                                                                                        	// The trigger settings that determine how and when the flow runs.
                                                                                        	TriggerConfig *types.TriggerConfig
                                                                                        
                                                                                        	// Metadata pertaining to the operation's result.
                                                                                        	ResultMetadata middleware.Metadata
                                                                                        }

                                                                                        type EndpointResolver

                                                                                        type EndpointResolver interface {
                                                                                        	ResolveEndpoint(region string, options EndpointResolverOptions) (aws.Endpoint, error)
                                                                                        }

                                                                                          EndpointResolver interface for resolving service endpoints.

                                                                                          func EndpointResolverFromURL

                                                                                          func EndpointResolverFromURL(url string, optFns ...func(*aws.Endpoint)) EndpointResolver

                                                                                            EndpointResolverFromURL returns an EndpointResolver configured using the provided endpoint url. By default, the resolved endpoint resolver uses the client region as signing region, and the endpoint source is set to EndpointSourceCustom.You can provide functional options to configure endpoint values for the resolved endpoint.

                                                                                            type EndpointResolverFunc

                                                                                            type EndpointResolverFunc func(region string, options EndpointResolverOptions) (aws.Endpoint, error)

                                                                                              EndpointResolverFunc is a helper utility that wraps a function so it satisfies the EndpointResolver interface. This is useful when you want to add additional endpoint resolving logic, or stub out specific endpoints with custom values.

                                                                                              func (EndpointResolverFunc) ResolveEndpoint

                                                                                              func (fn EndpointResolverFunc) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error)

                                                                                              type EndpointResolverOptions

                                                                                              type EndpointResolverOptions = internalendpoints.Options

                                                                                                EndpointResolverOptions is the service endpoint resolver options

                                                                                                type HTTPClient

                                                                                                type HTTPClient interface {
                                                                                                	Do(*http.Request) (*http.Response, error)
                                                                                                }

                                                                                                type HTTPSignerV4

                                                                                                type HTTPSignerV4 interface {
                                                                                                	SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time, optFns ...func(*v4.SignerOptions)) error
                                                                                                }

                                                                                                type ListConnectorEntitiesInput

                                                                                                type ListConnectorEntitiesInput struct {
                                                                                                
                                                                                                	// The name of the connector profile. The name is unique for each ConnectorProfile
                                                                                                	// in the AWS account, and is used to query the downstream connector.
                                                                                                	ConnectorProfileName *string
                                                                                                
                                                                                                	// The type of connector, such as Salesforce, Amplitude, and so on.
                                                                                                	ConnectorType types.ConnectorType
                                                                                                
                                                                                                	// This optional parameter is specific to connector implementation. Some connectors
                                                                                                	// support multiple levels or categories of entities. You can find out the list of
                                                                                                	// roots for such providers by sending a request without the entitiesPath
                                                                                                	// parameter. If the connector supports entities at different roots, this initial
                                                                                                	// request returns the list of roots. Otherwise, this request returns all entities
                                                                                                	// supported by the provider.
                                                                                                	EntitiesPath *string
                                                                                                }

                                                                                                type ListConnectorEntitiesOutput

                                                                                                type ListConnectorEntitiesOutput struct {
                                                                                                
                                                                                                	// The response of ListConnectorEntities lists entities grouped by category. This
                                                                                                	// map's key represents the group name, and its value contains the list of entities
                                                                                                	// belonging to that group.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	ConnectorEntityMap map[string][]types.ConnectorEntity
                                                                                                
                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                	ResultMetadata middleware.Metadata
                                                                                                }

                                                                                                type ListFlowsAPIClient

                                                                                                type ListFlowsAPIClient interface {
                                                                                                	ListFlows(context.Context, *ListFlowsInput, ...func(*Options)) (*ListFlowsOutput, error)
                                                                                                }

                                                                                                  ListFlowsAPIClient is a client that implements the ListFlows operation.

                                                                                                  type ListFlowsInput

                                                                                                  type ListFlowsInput struct {
                                                                                                  
                                                                                                  	// Specifies the maximum number of items that should be returned in the result set.
                                                                                                  	MaxResults *int32
                                                                                                  
                                                                                                  	// The pagination token for next page of data.
                                                                                                  	NextToken *string
                                                                                                  }

                                                                                                  type ListFlowsOutput

                                                                                                  type ListFlowsOutput struct {
                                                                                                  
                                                                                                  	// The list of flows associated with your account.
                                                                                                  	Flows []types.FlowDefinition
                                                                                                  
                                                                                                  	// The pagination token for next page of data.
                                                                                                  	NextToken *string
                                                                                                  
                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                  }

                                                                                                  type ListFlowsPaginator

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

                                                                                                    ListFlowsPaginator is a paginator for ListFlows

                                                                                                    func NewListFlowsPaginator

                                                                                                    func NewListFlowsPaginator(client ListFlowsAPIClient, params *ListFlowsInput, optFns ...func(*ListFlowsPaginatorOptions)) *ListFlowsPaginator

                                                                                                      NewListFlowsPaginator returns a new ListFlowsPaginator

                                                                                                      func (*ListFlowsPaginator) HasMorePages

                                                                                                      func (p *ListFlowsPaginator) HasMorePages() bool

                                                                                                        HasMorePages returns a boolean indicating whether more pages are available

                                                                                                        func (*ListFlowsPaginator) NextPage

                                                                                                        func (p *ListFlowsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListFlowsOutput, error)

                                                                                                          NextPage retrieves the next ListFlows page.

                                                                                                          type ListFlowsPaginatorOptions

                                                                                                          type ListFlowsPaginatorOptions struct {
                                                                                                          	// Specifies the maximum number of items that should be returned in the result set.
                                                                                                          	Limit int32
                                                                                                          
                                                                                                          	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                          	// that matches the most recent token provided to the service.
                                                                                                          	StopOnDuplicateToken bool
                                                                                                          }

                                                                                                            ListFlowsPaginatorOptions is the paginator options for ListFlows

                                                                                                            type ListTagsForResourceInput

                                                                                                            type ListTagsForResourceInput struct {
                                                                                                            
                                                                                                            	// The Amazon Resource Name (ARN) of the specified flow.
                                                                                                            	//
                                                                                                            	// This member is required.
                                                                                                            	ResourceArn *string
                                                                                                            }

                                                                                                            type ListTagsForResourceOutput

                                                                                                            type ListTagsForResourceOutput struct {
                                                                                                            
                                                                                                            	// The tags used to organize, track, or control access for your flow.
                                                                                                            	Tags map[string]string
                                                                                                            
                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                            }

                                                                                                            type Options

                                                                                                            type Options struct {
                                                                                                            	// Set of options to modify how an operation is invoked. These apply to all
                                                                                                            	// operations invoked for this client. Use functional options on operation call to
                                                                                                            	// modify this list for per operation behavior.
                                                                                                            	APIOptions []func(*middleware.Stack) error
                                                                                                            
                                                                                                            	// Configures the events that will be sent to the configured logger.
                                                                                                            	ClientLogMode aws.ClientLogMode
                                                                                                            
                                                                                                            	// The credentials object to use when signing requests.
                                                                                                            	Credentials aws.CredentialsProvider
                                                                                                            
                                                                                                            	// The endpoint options to be used when attempting to resolve an endpoint.
                                                                                                            	EndpointOptions EndpointResolverOptions
                                                                                                            
                                                                                                            	// The service endpoint resolver.
                                                                                                            	EndpointResolver EndpointResolver
                                                                                                            
                                                                                                            	// Signature Version 4 (SigV4) Signer
                                                                                                            	HTTPSignerV4 HTTPSignerV4
                                                                                                            
                                                                                                            	// The logger writer interface to write logging messages to.
                                                                                                            	Logger logging.Logger
                                                                                                            
                                                                                                            	// The region to send requests to. (Required)
                                                                                                            	Region string
                                                                                                            
                                                                                                            	// Retryer guides how HTTP requests should be retried in case of recoverable
                                                                                                            	// failures. When nil the API client will use a default retryer.
                                                                                                            	Retryer aws.Retryer
                                                                                                            
                                                                                                            	// The HTTP client to invoke API calls with. Defaults to client's default HTTP
                                                                                                            	// implementation if nil.
                                                                                                            	HTTPClient HTTPClient
                                                                                                            }

                                                                                                            func (Options) Copy

                                                                                                            func (o Options) Copy() Options

                                                                                                              Copy creates a clone where the APIOptions list is deep copied.

                                                                                                              type ResolveEndpoint

                                                                                                              type ResolveEndpoint struct {
                                                                                                              	Resolver EndpointResolver
                                                                                                              	Options  EndpointResolverOptions
                                                                                                              }

                                                                                                              func (*ResolveEndpoint) HandleSerialize

                                                                                                              func (*ResolveEndpoint) ID

                                                                                                              func (*ResolveEndpoint) ID() string

                                                                                                              type StartFlowInput

                                                                                                              type StartFlowInput struct {
                                                                                                              
                                                                                                              	// The specified name of the flow. Spaces are not allowed. Use underscores (_) or
                                                                                                              	// hyphens (-) only.
                                                                                                              	//
                                                                                                              	// This member is required.
                                                                                                              	FlowName *string
                                                                                                              }

                                                                                                              type StartFlowOutput

                                                                                                              type StartFlowOutput struct {
                                                                                                              
                                                                                                              	// Returns the internal execution ID of an on-demand flow when the flow is started.
                                                                                                              	// For scheduled or event-triggered flows, this value is null.
                                                                                                              	ExecutionId *string
                                                                                                              
                                                                                                              	// The flow's Amazon Resource Name (ARN).
                                                                                                              	FlowArn *string
                                                                                                              
                                                                                                              	// Indicates the current status of the flow.
                                                                                                              	FlowStatus types.FlowStatus
                                                                                                              
                                                                                                              	// Metadata pertaining to the operation's result.
                                                                                                              	ResultMetadata middleware.Metadata
                                                                                                              }

                                                                                                              type StopFlowInput

                                                                                                              type StopFlowInput struct {
                                                                                                              
                                                                                                              	// The specified name of the flow. Spaces are not allowed. Use underscores (_) or
                                                                                                              	// hyphens (-) only.
                                                                                                              	//
                                                                                                              	// This member is required.
                                                                                                              	FlowName *string
                                                                                                              }

                                                                                                              type StopFlowOutput

                                                                                                              type StopFlowOutput struct {
                                                                                                              
                                                                                                              	// The flow's Amazon Resource Name (ARN).
                                                                                                              	FlowArn *string
                                                                                                              
                                                                                                              	// Indicates the current status of the flow.
                                                                                                              	FlowStatus types.FlowStatus
                                                                                                              
                                                                                                              	// Metadata pertaining to the operation's result.
                                                                                                              	ResultMetadata middleware.Metadata
                                                                                                              }

                                                                                                              type TagResourceInput

                                                                                                              type TagResourceInput struct {
                                                                                                              
                                                                                                              	// The Amazon Resource Name (ARN) of the flow that you want to tag.
                                                                                                              	//
                                                                                                              	// This member is required.
                                                                                                              	ResourceArn *string
                                                                                                              
                                                                                                              	// The tags used to organize, track, or control access for your flow.
                                                                                                              	//
                                                                                                              	// This member is required.
                                                                                                              	Tags map[string]string
                                                                                                              }

                                                                                                              type TagResourceOutput

                                                                                                              type TagResourceOutput struct {
                                                                                                              	// Metadata pertaining to the operation's result.
                                                                                                              	ResultMetadata middleware.Metadata
                                                                                                              }

                                                                                                              type UntagResourceInput

                                                                                                              type UntagResourceInput struct {
                                                                                                              
                                                                                                              	// The Amazon Resource Name (ARN) of the flow that you want to untag.
                                                                                                              	//
                                                                                                              	// This member is required.
                                                                                                              	ResourceArn *string
                                                                                                              
                                                                                                              	// The tag keys associated with the tag that you want to remove from your flow.
                                                                                                              	//
                                                                                                              	// This member is required.
                                                                                                              	TagKeys []string
                                                                                                              }

                                                                                                              type UntagResourceOutput

                                                                                                              type UntagResourceOutput struct {
                                                                                                              	// Metadata pertaining to the operation's result.
                                                                                                              	ResultMetadata middleware.Metadata
                                                                                                              }

                                                                                                              type UpdateConnectorProfileInput

                                                                                                              type UpdateConnectorProfileInput struct {
                                                                                                              
                                                                                                              	// Indicates the connection mode and if it is public or private.
                                                                                                              	//
                                                                                                              	// This member is required.
                                                                                                              	ConnectionMode types.ConnectionMode
                                                                                                              
                                                                                                              	// Defines the connector-specific profile configuration and credentials.
                                                                                                              	//
                                                                                                              	// This member is required.
                                                                                                              	ConnectorProfileConfig *types.ConnectorProfileConfig
                                                                                                              
                                                                                                              	// The name of the connector profile and is unique for each ConnectorProfile in the
                                                                                                              	// AWS Account.
                                                                                                              	//
                                                                                                              	// This member is required.
                                                                                                              	ConnectorProfileName *string
                                                                                                              }

                                                                                                              type UpdateConnectorProfileOutput

                                                                                                              type UpdateConnectorProfileOutput struct {
                                                                                                              
                                                                                                              	// The Amazon Resource Name (ARN) of the connector profile.
                                                                                                              	ConnectorProfileArn *string
                                                                                                              
                                                                                                              	// Metadata pertaining to the operation's result.
                                                                                                              	ResultMetadata middleware.Metadata
                                                                                                              }

                                                                                                              type UpdateFlowInput

                                                                                                              type UpdateFlowInput struct {
                                                                                                              
                                                                                                              	// The configuration that controls how Amazon AppFlow transfers data to the
                                                                                                              	// destination connector.
                                                                                                              	//
                                                                                                              	// This member is required.
                                                                                                              	DestinationFlowConfigList []types.DestinationFlowConfig
                                                                                                              
                                                                                                              	// The specified name of the flow. Spaces are not allowed. Use underscores (_) or
                                                                                                              	// hyphens (-) only.
                                                                                                              	//
                                                                                                              	// This member is required.
                                                                                                              	FlowName *string
                                                                                                              
                                                                                                              	// A list of tasks that Amazon AppFlow performs while transferring the data in the
                                                                                                              	// flow run.
                                                                                                              	//
                                                                                                              	// This member is required.
                                                                                                              	Tasks []types.Task
                                                                                                              
                                                                                                              	// The trigger settings that determine how and when the flow runs.
                                                                                                              	//
                                                                                                              	// This member is required.
                                                                                                              	TriggerConfig *types.TriggerConfig
                                                                                                              
                                                                                                              	// A description of the flow.
                                                                                                              	Description *string
                                                                                                              
                                                                                                              	// Contains information about the configuration of the source connector used in the
                                                                                                              	// flow.
                                                                                                              	SourceFlowConfig *types.SourceFlowConfig
                                                                                                              }

                                                                                                              type UpdateFlowOutput

                                                                                                              type UpdateFlowOutput struct {
                                                                                                              
                                                                                                              	// Indicates the current status of the flow.
                                                                                                              	FlowStatus types.FlowStatus
                                                                                                              
                                                                                                              	// Metadata pertaining to the operation's result.
                                                                                                              	ResultMetadata middleware.Metadata
                                                                                                              }

                                                                                                              Directories

                                                                                                              Path Synopsis
                                                                                                              internal