Documentation

Overview

    Package appsync provides the API client, operations, and parameter types for AWS AppSync.

    AWS AppSync provides API actions for creating and interacting with data sources using GraphQL from your application.

    Index

    Constants

    View Source
    const ServiceAPIVersion = "2017-07-25"
    View Source
    const ServiceID = "AppSync"

    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 AWS AppSync.

            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) CreateApiCache

                func (c *Client) CreateApiCache(ctx context.Context, params *CreateApiCacheInput, optFns ...func(*Options)) (*CreateApiCacheOutput, error)

                  Creates a cache for the GraphQL API.

                  func (*Client) CreateApiKey

                  func (c *Client) CreateApiKey(ctx context.Context, params *CreateApiKeyInput, optFns ...func(*Options)) (*CreateApiKeyOutput, error)

                    Creates a unique key that you can distribute to clients who are executing your API.

                    func (*Client) CreateDataSource

                    func (c *Client) CreateDataSource(ctx context.Context, params *CreateDataSourceInput, optFns ...func(*Options)) (*CreateDataSourceOutput, error)

                      Creates a DataSource object.

                      func (*Client) CreateFunction

                      func (c *Client) CreateFunction(ctx context.Context, params *CreateFunctionInput, optFns ...func(*Options)) (*CreateFunctionOutput, error)

                        Creates a Function object. A function is a reusable entity. Multiple functions can be used to compose the resolver logic.

                        func (*Client) CreateGraphqlApi

                        func (c *Client) CreateGraphqlApi(ctx context.Context, params *CreateGraphqlApiInput, optFns ...func(*Options)) (*CreateGraphqlApiOutput, error)

                          Creates a GraphqlApi object.

                          func (*Client) CreateResolver

                          func (c *Client) CreateResolver(ctx context.Context, params *CreateResolverInput, optFns ...func(*Options)) (*CreateResolverOutput, error)

                            Creates a Resolver object. A resolver converts incoming requests into a format that a data source can understand and converts the data source's responses into GraphQL.

                            func (*Client) CreateType

                            func (c *Client) CreateType(ctx context.Context, params *CreateTypeInput, optFns ...func(*Options)) (*CreateTypeOutput, error)

                              Creates a Type object.

                              func (*Client) DeleteApiCache

                              func (c *Client) DeleteApiCache(ctx context.Context, params *DeleteApiCacheInput, optFns ...func(*Options)) (*DeleteApiCacheOutput, error)

                                Deletes an ApiCache object.

                                func (*Client) DeleteApiKey

                                func (c *Client) DeleteApiKey(ctx context.Context, params *DeleteApiKeyInput, optFns ...func(*Options)) (*DeleteApiKeyOutput, error)

                                  Deletes an API key.

                                  func (*Client) DeleteDataSource

                                  func (c *Client) DeleteDataSource(ctx context.Context, params *DeleteDataSourceInput, optFns ...func(*Options)) (*DeleteDataSourceOutput, error)

                                    Deletes a DataSource object.

                                    func (*Client) DeleteFunction

                                    func (c *Client) DeleteFunction(ctx context.Context, params *DeleteFunctionInput, optFns ...func(*Options)) (*DeleteFunctionOutput, error)

                                      Deletes a Function.

                                      func (*Client) DeleteGraphqlApi

                                      func (c *Client) DeleteGraphqlApi(ctx context.Context, params *DeleteGraphqlApiInput, optFns ...func(*Options)) (*DeleteGraphqlApiOutput, error)

                                        Deletes a GraphqlApi object.

                                        func (*Client) DeleteResolver

                                        func (c *Client) DeleteResolver(ctx context.Context, params *DeleteResolverInput, optFns ...func(*Options)) (*DeleteResolverOutput, error)

                                          Deletes a Resolver object.

                                          func (*Client) DeleteType

                                          func (c *Client) DeleteType(ctx context.Context, params *DeleteTypeInput, optFns ...func(*Options)) (*DeleteTypeOutput, error)

                                            Deletes a Type object.

                                            func (*Client) FlushApiCache

                                            func (c *Client) FlushApiCache(ctx context.Context, params *FlushApiCacheInput, optFns ...func(*Options)) (*FlushApiCacheOutput, error)

                                              Flushes an ApiCache object.

                                              func (*Client) GetApiCache

                                              func (c *Client) GetApiCache(ctx context.Context, params *GetApiCacheInput, optFns ...func(*Options)) (*GetApiCacheOutput, error)

                                                Retrieves an ApiCache object.

                                                func (*Client) GetDataSource

                                                func (c *Client) GetDataSource(ctx context.Context, params *GetDataSourceInput, optFns ...func(*Options)) (*GetDataSourceOutput, error)

                                                  Retrieves a DataSource object.

                                                  func (*Client) GetFunction

                                                  func (c *Client) GetFunction(ctx context.Context, params *GetFunctionInput, optFns ...func(*Options)) (*GetFunctionOutput, error)

                                                    Get a Function.

                                                    func (*Client) GetGraphqlApi

                                                    func (c *Client) GetGraphqlApi(ctx context.Context, params *GetGraphqlApiInput, optFns ...func(*Options)) (*GetGraphqlApiOutput, error)

                                                      Retrieves a GraphqlApi object.

                                                      func (*Client) GetIntrospectionSchema

                                                      func (c *Client) GetIntrospectionSchema(ctx context.Context, params *GetIntrospectionSchemaInput, optFns ...func(*Options)) (*GetIntrospectionSchemaOutput, error)

                                                        Retrieves the introspection schema for a GraphQL API.

                                                        func (*Client) GetResolver

                                                        func (c *Client) GetResolver(ctx context.Context, params *GetResolverInput, optFns ...func(*Options)) (*GetResolverOutput, error)

                                                          Retrieves a Resolver object.

                                                          func (*Client) GetSchemaCreationStatus

                                                          func (c *Client) GetSchemaCreationStatus(ctx context.Context, params *GetSchemaCreationStatusInput, optFns ...func(*Options)) (*GetSchemaCreationStatusOutput, error)

                                                            Retrieves the current status of a schema creation operation.

                                                            func (*Client) GetType

                                                            func (c *Client) GetType(ctx context.Context, params *GetTypeInput, optFns ...func(*Options)) (*GetTypeOutput, error)

                                                              Retrieves a Type object.

                                                              func (*Client) ListApiKeys

                                                              func (c *Client) ListApiKeys(ctx context.Context, params *ListApiKeysInput, optFns ...func(*Options)) (*ListApiKeysOutput, error)

                                                                Lists the API keys for a given API. API keys are deleted automatically 60 days after they expire. However, they may still be included in the response until they have actually been deleted. You can safely call DeleteApiKey to manually delete a key before it's automatically deleted.

                                                                func (*Client) ListDataSources

                                                                func (c *Client) ListDataSources(ctx context.Context, params *ListDataSourcesInput, optFns ...func(*Options)) (*ListDataSourcesOutput, error)

                                                                  Lists the data sources for a given API.

                                                                  func (*Client) ListFunctions

                                                                  func (c *Client) ListFunctions(ctx context.Context, params *ListFunctionsInput, optFns ...func(*Options)) (*ListFunctionsOutput, error)

                                                                    List multiple functions.

                                                                    func (*Client) ListGraphqlApis

                                                                    func (c *Client) ListGraphqlApis(ctx context.Context, params *ListGraphqlApisInput, optFns ...func(*Options)) (*ListGraphqlApisOutput, error)

                                                                      Lists your GraphQL APIs.

                                                                      func (*Client) ListResolvers

                                                                      func (c *Client) ListResolvers(ctx context.Context, params *ListResolversInput, optFns ...func(*Options)) (*ListResolversOutput, error)

                                                                        Lists the resolvers for a given API and type.

                                                                        func (*Client) ListResolversByFunction

                                                                        func (c *Client) ListResolversByFunction(ctx context.Context, params *ListResolversByFunctionInput, optFns ...func(*Options)) (*ListResolversByFunctionOutput, error)

                                                                          List the resolvers that are associated with a specific function.

                                                                          func (*Client) ListTagsForResource

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

                                                                            Lists the tags for a resource.

                                                                            func (*Client) ListTypes

                                                                            func (c *Client) ListTypes(ctx context.Context, params *ListTypesInput, optFns ...func(*Options)) (*ListTypesOutput, error)

                                                                              Lists the types for a given API.

                                                                              func (*Client) StartSchemaCreation

                                                                              func (c *Client) StartSchemaCreation(ctx context.Context, params *StartSchemaCreationInput, optFns ...func(*Options)) (*StartSchemaCreationOutput, error)

                                                                                Adds a new schema to your GraphQL API. This operation is asynchronous. Use to determine when it has completed.

                                                                                func (*Client) TagResource

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

                                                                                  Tags a resource with user-supplied tags.

                                                                                  func (*Client) UntagResource

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

                                                                                    Untags a resource.

                                                                                    func (*Client) UpdateApiCache

                                                                                    func (c *Client) UpdateApiCache(ctx context.Context, params *UpdateApiCacheInput, optFns ...func(*Options)) (*UpdateApiCacheOutput, error)

                                                                                      Updates the cache for the GraphQL API.

                                                                                      func (*Client) UpdateApiKey

                                                                                      func (c *Client) UpdateApiKey(ctx context.Context, params *UpdateApiKeyInput, optFns ...func(*Options)) (*UpdateApiKeyOutput, error)

                                                                                        Updates an API key. The key can be updated while it is not deleted.

                                                                                        func (*Client) UpdateDataSource

                                                                                        func (c *Client) UpdateDataSource(ctx context.Context, params *UpdateDataSourceInput, optFns ...func(*Options)) (*UpdateDataSourceOutput, error)

                                                                                          Updates a DataSource object.

                                                                                          func (*Client) UpdateFunction

                                                                                          func (c *Client) UpdateFunction(ctx context.Context, params *UpdateFunctionInput, optFns ...func(*Options)) (*UpdateFunctionOutput, error)

                                                                                            Updates a Function object.

                                                                                            func (*Client) UpdateGraphqlApi

                                                                                            func (c *Client) UpdateGraphqlApi(ctx context.Context, params *UpdateGraphqlApiInput, optFns ...func(*Options)) (*UpdateGraphqlApiOutput, error)

                                                                                              Updates a GraphqlApi object.

                                                                                              func (*Client) UpdateResolver

                                                                                              func (c *Client) UpdateResolver(ctx context.Context, params *UpdateResolverInput, optFns ...func(*Options)) (*UpdateResolverOutput, error)

                                                                                                Updates a Resolver object.

                                                                                                func (*Client) UpdateType

                                                                                                func (c *Client) UpdateType(ctx context.Context, params *UpdateTypeInput, optFns ...func(*Options)) (*UpdateTypeOutput, error)

                                                                                                  Updates a Type object.

                                                                                                  type CreateApiCacheInput

                                                                                                  type CreateApiCacheInput struct {
                                                                                                  
                                                                                                  	// Caching behavior.
                                                                                                  	//
                                                                                                  	// * FULL_REQUEST_CACHING: All requests are fully cached.
                                                                                                  	//
                                                                                                  	// *
                                                                                                  	// PER_RESOLVER_CACHING: Individual resolvers that you specify are cached.
                                                                                                  	//
                                                                                                  	// This member is required.
                                                                                                  	ApiCachingBehavior types.ApiCachingBehavior
                                                                                                  
                                                                                                  	// The GraphQL API Id.
                                                                                                  	//
                                                                                                  	// This member is required.
                                                                                                  	ApiId *string
                                                                                                  
                                                                                                  	// TTL in seconds for cache entries. Valid values are between 1 and 3600 seconds.
                                                                                                  	//
                                                                                                  	// This member is required.
                                                                                                  	Ttl int64
                                                                                                  
                                                                                                  	// The cache instance type. Valid values are
                                                                                                  	//
                                                                                                  	// * SMALL
                                                                                                  	//
                                                                                                  	// * MEDIUM
                                                                                                  	//
                                                                                                  	// * LARGE
                                                                                                  	//
                                                                                                  	// *
                                                                                                  	// XLARGE
                                                                                                  	//
                                                                                                  	// * LARGE_2X
                                                                                                  	//
                                                                                                  	// * LARGE_4X
                                                                                                  	//
                                                                                                  	// * LARGE_8X (not available in all regions)
                                                                                                  	//
                                                                                                  	// *
                                                                                                  	// LARGE_12X
                                                                                                  	//
                                                                                                  	// Historically, instance types were identified by an EC2-style value.
                                                                                                  	// As of July 2020, this is deprecated, and the generic identifiers above should be
                                                                                                  	// used. The following legacy instance types are available, but their use is
                                                                                                  	// discouraged:
                                                                                                  	//
                                                                                                  	// * T2_SMALL: A t2.small instance type.
                                                                                                  	//
                                                                                                  	// * T2_MEDIUM: A t2.medium
                                                                                                  	// instance type.
                                                                                                  	//
                                                                                                  	// * R4_LARGE: A r4.large instance type.
                                                                                                  	//
                                                                                                  	// * R4_XLARGE: A r4.xlarge
                                                                                                  	// instance type.
                                                                                                  	//
                                                                                                  	// * R4_2XLARGE: A r4.2xlarge instance type.
                                                                                                  	//
                                                                                                  	// * R4_4XLARGE: A
                                                                                                  	// r4.4xlarge instance type.
                                                                                                  	//
                                                                                                  	// * R4_8XLARGE: A r4.8xlarge instance type.
                                                                                                  	//
                                                                                                  	// This member is required.
                                                                                                  	Type types.ApiCacheType
                                                                                                  
                                                                                                  	// At rest encryption flag for cache. This setting cannot be updated after
                                                                                                  	// creation.
                                                                                                  	AtRestEncryptionEnabled bool
                                                                                                  
                                                                                                  	// Transit encryption flag when connecting to cache. This setting cannot be updated
                                                                                                  	// after creation.
                                                                                                  	TransitEncryptionEnabled bool
                                                                                                  }

                                                                                                    Represents the input of a CreateApiCache operation.

                                                                                                    type CreateApiCacheOutput

                                                                                                    type CreateApiCacheOutput struct {
                                                                                                    
                                                                                                    	// The ApiCache object.
                                                                                                    	ApiCache *types.ApiCache
                                                                                                    
                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                    }

                                                                                                      Represents the output of a CreateApiCache operation.

                                                                                                      type CreateApiKeyInput

                                                                                                      type CreateApiKeyInput struct {
                                                                                                      
                                                                                                      	// The ID for your GraphQL API.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	ApiId *string
                                                                                                      
                                                                                                      	// A description of the purpose of the API key.
                                                                                                      	Description *string
                                                                                                      
                                                                                                      	// The time from creation time after which the API key expires. The date is
                                                                                                      	// represented as seconds since the epoch, rounded down to the nearest hour. The
                                                                                                      	// default value for this parameter is 7 days from creation time. For more
                                                                                                      	// information, see .
                                                                                                      	Expires int64
                                                                                                      }

                                                                                                      type CreateApiKeyOutput

                                                                                                      type CreateApiKeyOutput struct {
                                                                                                      
                                                                                                      	// The API key.
                                                                                                      	ApiKey *types.ApiKey
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type CreateDataSourceInput

                                                                                                      type CreateDataSourceInput struct {
                                                                                                      
                                                                                                      	// The API ID for the GraphQL API for the DataSource.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	ApiId *string
                                                                                                      
                                                                                                      	// A user-supplied name for the DataSource.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	Name *string
                                                                                                      
                                                                                                      	// The type of the DataSource.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	Type types.DataSourceType
                                                                                                      
                                                                                                      	// A description of the DataSource.
                                                                                                      	Description *string
                                                                                                      
                                                                                                      	// Amazon DynamoDB settings.
                                                                                                      	DynamodbConfig *types.DynamodbDataSourceConfig
                                                                                                      
                                                                                                      	// Amazon Elasticsearch Service settings.
                                                                                                      	ElasticsearchConfig *types.ElasticsearchDataSourceConfig
                                                                                                      
                                                                                                      	// HTTP endpoint settings.
                                                                                                      	HttpConfig *types.HttpDataSourceConfig
                                                                                                      
                                                                                                      	// AWS Lambda settings.
                                                                                                      	LambdaConfig *types.LambdaDataSourceConfig
                                                                                                      
                                                                                                      	// Relational database settings.
                                                                                                      	RelationalDatabaseConfig *types.RelationalDatabaseDataSourceConfig
                                                                                                      
                                                                                                      	// The AWS IAM service role ARN for the data source. The system assumes this role
                                                                                                      	// when accessing the data source.
                                                                                                      	ServiceRoleArn *string
                                                                                                      }

                                                                                                      type CreateDataSourceOutput

                                                                                                      type CreateDataSourceOutput struct {
                                                                                                      
                                                                                                      	// The DataSource object.
                                                                                                      	DataSource *types.DataSource
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type CreateFunctionInput

                                                                                                      type CreateFunctionInput struct {
                                                                                                      
                                                                                                      	// The GraphQL API ID.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	ApiId *string
                                                                                                      
                                                                                                      	// The FunctionDataSource name.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	DataSourceName *string
                                                                                                      
                                                                                                      	// The version of the request mapping template. Currently the supported value is
                                                                                                      	// 2018-05-29.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	FunctionVersion *string
                                                                                                      
                                                                                                      	// The Function name. The function name does not have to be unique.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	Name *string
                                                                                                      
                                                                                                      	// The Function description.
                                                                                                      	Description *string
                                                                                                      
                                                                                                      	// The Function request mapping template. Functions support only the 2018-05-29
                                                                                                      	// version of the request mapping template.
                                                                                                      	RequestMappingTemplate *string
                                                                                                      
                                                                                                      	// The Function response mapping template.
                                                                                                      	ResponseMappingTemplate *string
                                                                                                      }

                                                                                                      type CreateFunctionOutput

                                                                                                      type CreateFunctionOutput struct {
                                                                                                      
                                                                                                      	// The Function object.
                                                                                                      	FunctionConfiguration *types.FunctionConfiguration
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type CreateGraphqlApiInput

                                                                                                      type CreateGraphqlApiInput struct {
                                                                                                      
                                                                                                      	// The authentication type: API key, AWS IAM, OIDC, or Amazon Cognito user pools.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	AuthenticationType types.AuthenticationType
                                                                                                      
                                                                                                      	// A user-supplied name for the GraphqlApi.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	Name *string
                                                                                                      
                                                                                                      	// A list of additional authentication providers for the GraphqlApi API.
                                                                                                      	AdditionalAuthenticationProviders []types.AdditionalAuthenticationProvider
                                                                                                      
                                                                                                      	// The Amazon CloudWatch Logs configuration.
                                                                                                      	LogConfig *types.LogConfig
                                                                                                      
                                                                                                      	// The OpenID Connect configuration.
                                                                                                      	OpenIDConnectConfig *types.OpenIDConnectConfig
                                                                                                      
                                                                                                      	// A TagMap object.
                                                                                                      	Tags map[string]string
                                                                                                      
                                                                                                      	// The Amazon Cognito user pool configuration.
                                                                                                      	UserPoolConfig *types.UserPoolConfig
                                                                                                      
                                                                                                      	// A flag indicating whether to enable X-Ray tracing for the GraphqlApi.
                                                                                                      	XrayEnabled bool
                                                                                                      }

                                                                                                      type CreateGraphqlApiOutput

                                                                                                      type CreateGraphqlApiOutput struct {
                                                                                                      
                                                                                                      	// The GraphqlApi.
                                                                                                      	GraphqlApi *types.GraphqlApi
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type CreateResolverInput

                                                                                                      type CreateResolverInput struct {
                                                                                                      
                                                                                                      	// The ID for the GraphQL API for which the resolver is being created.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	ApiId *string
                                                                                                      
                                                                                                      	// The name of the field to attach the resolver to.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	FieldName *string
                                                                                                      
                                                                                                      	// The name of the Type.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	TypeName *string
                                                                                                      
                                                                                                      	// The caching configuration for the resolver.
                                                                                                      	CachingConfig *types.CachingConfig
                                                                                                      
                                                                                                      	// The name of the data source for which the resolver is being created.
                                                                                                      	DataSourceName *string
                                                                                                      
                                                                                                      	// The resolver type.
                                                                                                      	//
                                                                                                      	// * UNIT: A UNIT resolver type. A UNIT resolver is the default
                                                                                                      	// resolver type. A UNIT resolver enables you to execute a GraphQL query against a
                                                                                                      	// single data source.
                                                                                                      	//
                                                                                                      	// * PIPELINE: A PIPELINE resolver type. A PIPELINE resolver
                                                                                                      	// enables you to execute a series of Function in a serial manner. You can use a
                                                                                                      	// pipeline resolver to execute a GraphQL query against multiple data sources.
                                                                                                      	Kind types.ResolverKind
                                                                                                      
                                                                                                      	// The PipelineConfig.
                                                                                                      	PipelineConfig *types.PipelineConfig
                                                                                                      
                                                                                                      	// The mapping template to be used for requests. A resolver uses a request mapping
                                                                                                      	// template to convert a GraphQL expression into a format that a data source can
                                                                                                      	// understand. Mapping templates are written in Apache Velocity Template Language
                                                                                                      	// (VTL). VTL request mapping templates are optional when using a Lambda data
                                                                                                      	// source. For all other data sources, VTL request and response mapping templates
                                                                                                      	// are required.
                                                                                                      	RequestMappingTemplate *string
                                                                                                      
                                                                                                      	// The mapping template to be used for responses from the data source.
                                                                                                      	ResponseMappingTemplate *string
                                                                                                      
                                                                                                      	// The SyncConfig for a resolver attached to a versioned datasource.
                                                                                                      	SyncConfig *types.SyncConfig
                                                                                                      }

                                                                                                      type CreateResolverOutput

                                                                                                      type CreateResolverOutput struct {
                                                                                                      
                                                                                                      	// The Resolver object.
                                                                                                      	Resolver *types.Resolver
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type CreateTypeInput

                                                                                                      type CreateTypeInput struct {
                                                                                                      
                                                                                                      	// The API ID.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	ApiId *string
                                                                                                      
                                                                                                      	// The type definition, in GraphQL Schema Definition Language (SDL) format. For
                                                                                                      	// more information, see the GraphQL SDL documentation
                                                                                                      	// (http://graphql.org/learn/schema/).
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	Definition *string
                                                                                                      
                                                                                                      	// The type format: SDL or JSON.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	Format types.TypeDefinitionFormat
                                                                                                      }

                                                                                                      type CreateTypeOutput

                                                                                                      type CreateTypeOutput struct {
                                                                                                      
                                                                                                      	// The Type object.
                                                                                                      	Type *types.Type
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type DeleteApiCacheInput

                                                                                                      type DeleteApiCacheInput struct {
                                                                                                      
                                                                                                      	// The API ID.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	ApiId *string
                                                                                                      }

                                                                                                        Represents the input of a DeleteApiCache operation.

                                                                                                        type DeleteApiCacheOutput

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

                                                                                                          Represents the output of a DeleteApiCache operation.

                                                                                                          type DeleteApiKeyInput

                                                                                                          type DeleteApiKeyInput struct {
                                                                                                          
                                                                                                          	// The API ID.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	ApiId *string
                                                                                                          
                                                                                                          	// The ID for the API key.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	Id *string
                                                                                                          }

                                                                                                          type DeleteApiKeyOutput

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

                                                                                                          type DeleteDataSourceInput

                                                                                                          type DeleteDataSourceInput struct {
                                                                                                          
                                                                                                          	// The API ID.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	ApiId *string
                                                                                                          
                                                                                                          	// The name of the data source.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	Name *string
                                                                                                          }

                                                                                                          type DeleteDataSourceOutput

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

                                                                                                          type DeleteFunctionInput

                                                                                                          type DeleteFunctionInput struct {
                                                                                                          
                                                                                                          	// The GraphQL API ID.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	ApiId *string
                                                                                                          
                                                                                                          	// The Function ID.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	FunctionId *string
                                                                                                          }

                                                                                                          type DeleteFunctionOutput

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

                                                                                                          type DeleteGraphqlApiInput

                                                                                                          type DeleteGraphqlApiInput struct {
                                                                                                          
                                                                                                          	// The API ID.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	ApiId *string
                                                                                                          }

                                                                                                          type DeleteGraphqlApiOutput

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

                                                                                                          type DeleteResolverInput

                                                                                                          type DeleteResolverInput struct {
                                                                                                          
                                                                                                          	// The API ID.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	ApiId *string
                                                                                                          
                                                                                                          	// The resolver field name.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	FieldName *string
                                                                                                          
                                                                                                          	// The name of the resolver type.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	TypeName *string
                                                                                                          }

                                                                                                          type DeleteResolverOutput

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

                                                                                                          type DeleteTypeInput

                                                                                                          type DeleteTypeInput struct {
                                                                                                          
                                                                                                          	// The API ID.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	ApiId *string
                                                                                                          
                                                                                                          	// The type name.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	TypeName *string
                                                                                                          }

                                                                                                          type DeleteTypeOutput

                                                                                                          type DeleteTypeOutput struct {
                                                                                                          	// 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 FlushApiCacheInput

                                                                                                                  type FlushApiCacheInput struct {
                                                                                                                  
                                                                                                                  	// The API ID.
                                                                                                                  	//
                                                                                                                  	// This member is required.
                                                                                                                  	ApiId *string
                                                                                                                  }

                                                                                                                    Represents the input of a FlushApiCache operation.

                                                                                                                    type FlushApiCacheOutput

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

                                                                                                                      Represents the output of a FlushApiCache operation.

                                                                                                                      type GetApiCacheInput

                                                                                                                      type GetApiCacheInput struct {
                                                                                                                      
                                                                                                                      	// The API ID.
                                                                                                                      	//
                                                                                                                      	// This member is required.
                                                                                                                      	ApiId *string
                                                                                                                      }

                                                                                                                        Represents the input of a GetApiCache operation.

                                                                                                                        type GetApiCacheOutput

                                                                                                                        type GetApiCacheOutput struct {
                                                                                                                        
                                                                                                                        	// The ApiCache object.
                                                                                                                        	ApiCache *types.ApiCache
                                                                                                                        
                                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                                        }

                                                                                                                          Represents the output of a GetApiCache operation.

                                                                                                                          type GetDataSourceInput

                                                                                                                          type GetDataSourceInput struct {
                                                                                                                          
                                                                                                                          	// The API ID.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	ApiId *string
                                                                                                                          
                                                                                                                          	// The name of the data source.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	Name *string
                                                                                                                          }

                                                                                                                          type GetDataSourceOutput

                                                                                                                          type GetDataSourceOutput struct {
                                                                                                                          
                                                                                                                          	// The DataSource object.
                                                                                                                          	DataSource *types.DataSource
                                                                                                                          
                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                          }

                                                                                                                          type GetFunctionInput

                                                                                                                          type GetFunctionInput struct {
                                                                                                                          
                                                                                                                          	// The GraphQL API ID.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	ApiId *string
                                                                                                                          
                                                                                                                          	// The Function ID.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	FunctionId *string
                                                                                                                          }

                                                                                                                          type GetFunctionOutput

                                                                                                                          type GetFunctionOutput struct {
                                                                                                                          
                                                                                                                          	// The Function object.
                                                                                                                          	FunctionConfiguration *types.FunctionConfiguration
                                                                                                                          
                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                          }

                                                                                                                          type GetGraphqlApiInput

                                                                                                                          type GetGraphqlApiInput struct {
                                                                                                                          
                                                                                                                          	// The API ID for the GraphQL API.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	ApiId *string
                                                                                                                          }

                                                                                                                          type GetGraphqlApiOutput

                                                                                                                          type GetGraphqlApiOutput struct {
                                                                                                                          
                                                                                                                          	// The GraphqlApi object.
                                                                                                                          	GraphqlApi *types.GraphqlApi
                                                                                                                          
                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                          }

                                                                                                                          type GetIntrospectionSchemaInput

                                                                                                                          type GetIntrospectionSchemaInput struct {
                                                                                                                          
                                                                                                                          	// The API ID.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	ApiId *string
                                                                                                                          
                                                                                                                          	// The schema format: SDL or JSON.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	Format types.OutputType
                                                                                                                          
                                                                                                                          	// A flag that specifies whether the schema introspection should contain
                                                                                                                          	// directives.
                                                                                                                          	IncludeDirectives *bool
                                                                                                                          }

                                                                                                                          type GetIntrospectionSchemaOutput

                                                                                                                          type GetIntrospectionSchemaOutput struct {
                                                                                                                          
                                                                                                                          	// The schema, in GraphQL Schema Definition Language (SDL) format. For more
                                                                                                                          	// information, see the GraphQL SDL documentation
                                                                                                                          	// (http://graphql.org/learn/schema/).
                                                                                                                          	Schema []byte
                                                                                                                          
                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                          }

                                                                                                                          type GetResolverInput

                                                                                                                          type GetResolverInput struct {
                                                                                                                          
                                                                                                                          	// The API ID.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	ApiId *string
                                                                                                                          
                                                                                                                          	// The resolver field name.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	FieldName *string
                                                                                                                          
                                                                                                                          	// The resolver type name.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	TypeName *string
                                                                                                                          }

                                                                                                                          type GetResolverOutput

                                                                                                                          type GetResolverOutput struct {
                                                                                                                          
                                                                                                                          	// The Resolver object.
                                                                                                                          	Resolver *types.Resolver
                                                                                                                          
                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                          }

                                                                                                                          type GetSchemaCreationStatusInput

                                                                                                                          type GetSchemaCreationStatusInput struct {
                                                                                                                          
                                                                                                                          	// The API ID.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	ApiId *string
                                                                                                                          }

                                                                                                                          type GetSchemaCreationStatusOutput

                                                                                                                          type GetSchemaCreationStatusOutput struct {
                                                                                                                          
                                                                                                                          	// Detailed information about the status of the schema creation operation.
                                                                                                                          	Details *string
                                                                                                                          
                                                                                                                          	// The current state of the schema (PROCESSING, FAILED, SUCCESS, or
                                                                                                                          	// NOT_APPLICABLE). When the schema is in the ACTIVE state, you can add data.
                                                                                                                          	Status types.SchemaStatus
                                                                                                                          
                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                          }

                                                                                                                          type GetTypeInput

                                                                                                                          type GetTypeInput struct {
                                                                                                                          
                                                                                                                          	// The API ID.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	ApiId *string
                                                                                                                          
                                                                                                                          	// The type format: SDL or JSON.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	Format types.TypeDefinitionFormat
                                                                                                                          
                                                                                                                          	// The type name.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	TypeName *string
                                                                                                                          }

                                                                                                                          type GetTypeOutput

                                                                                                                          type GetTypeOutput struct {
                                                                                                                          
                                                                                                                          	// The Type object.
                                                                                                                          	Type *types.Type
                                                                                                                          
                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                          }

                                                                                                                          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 ListApiKeysInput

                                                                                                                          type ListApiKeysInput struct {
                                                                                                                          
                                                                                                                          	// The API ID.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	ApiId *string
                                                                                                                          
                                                                                                                          	// The maximum number of results you want the request to return.
                                                                                                                          	MaxResults int32
                                                                                                                          
                                                                                                                          	// An identifier that was returned from the previous call to this operation, which
                                                                                                                          	// can be used to return the next set of items in the list.
                                                                                                                          	NextToken *string
                                                                                                                          }

                                                                                                                          type ListApiKeysOutput

                                                                                                                          type ListApiKeysOutput struct {
                                                                                                                          
                                                                                                                          	// The ApiKey objects.
                                                                                                                          	ApiKeys []types.ApiKey
                                                                                                                          
                                                                                                                          	// An identifier to be passed in the next request to this operation to return the
                                                                                                                          	// next set of items in the list.
                                                                                                                          	NextToken *string
                                                                                                                          
                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                          }

                                                                                                                          type ListDataSourcesInput

                                                                                                                          type ListDataSourcesInput struct {
                                                                                                                          
                                                                                                                          	// The API ID.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	ApiId *string
                                                                                                                          
                                                                                                                          	// The maximum number of results you want the request to return.
                                                                                                                          	MaxResults int32
                                                                                                                          
                                                                                                                          	// An identifier that was returned from the previous call to this operation, which
                                                                                                                          	// can be used to return the next set of items in the list.
                                                                                                                          	NextToken *string
                                                                                                                          }

                                                                                                                          type ListDataSourcesOutput

                                                                                                                          type ListDataSourcesOutput struct {
                                                                                                                          
                                                                                                                          	// The DataSource objects.
                                                                                                                          	DataSources []types.DataSource
                                                                                                                          
                                                                                                                          	// An identifier to be passed in the next request to this operation to return the
                                                                                                                          	// next set of items in the list.
                                                                                                                          	NextToken *string
                                                                                                                          
                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                          }

                                                                                                                          type ListFunctionsInput

                                                                                                                          type ListFunctionsInput struct {
                                                                                                                          
                                                                                                                          	// The GraphQL API ID.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	ApiId *string
                                                                                                                          
                                                                                                                          	// The maximum number of results you want the request to return.
                                                                                                                          	MaxResults int32
                                                                                                                          
                                                                                                                          	// An identifier that was returned from the previous call to this operation, which
                                                                                                                          	// can be used to return the next set of items in the list.
                                                                                                                          	NextToken *string
                                                                                                                          }

                                                                                                                          type ListFunctionsOutput

                                                                                                                          type ListFunctionsOutput struct {
                                                                                                                          
                                                                                                                          	// A list of Function objects.
                                                                                                                          	Functions []types.FunctionConfiguration
                                                                                                                          
                                                                                                                          	// An identifier that was returned from the previous call to this operation, which
                                                                                                                          	// can be used to return the next set of items in the list.
                                                                                                                          	NextToken *string
                                                                                                                          
                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                          }

                                                                                                                          type ListGraphqlApisInput

                                                                                                                          type ListGraphqlApisInput struct {
                                                                                                                          
                                                                                                                          	// The maximum number of results you want the request to return.
                                                                                                                          	MaxResults int32
                                                                                                                          
                                                                                                                          	// An identifier that was returned from the previous call to this operation, which
                                                                                                                          	// can be used to return the next set of items in the list.
                                                                                                                          	NextToken *string
                                                                                                                          }

                                                                                                                          type ListGraphqlApisOutput

                                                                                                                          type ListGraphqlApisOutput struct {
                                                                                                                          
                                                                                                                          	// The GraphqlApi objects.
                                                                                                                          	GraphqlApis []types.GraphqlApi
                                                                                                                          
                                                                                                                          	// An identifier to be passed in the next request to this operation to return the
                                                                                                                          	// next set of items in the list.
                                                                                                                          	NextToken *string
                                                                                                                          
                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                          }

                                                                                                                          type ListResolversByFunctionInput

                                                                                                                          type ListResolversByFunctionInput struct {
                                                                                                                          
                                                                                                                          	// The API ID.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	ApiId *string
                                                                                                                          
                                                                                                                          	// The Function ID.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	FunctionId *string
                                                                                                                          
                                                                                                                          	// The maximum number of results you want the request to return.
                                                                                                                          	MaxResults int32
                                                                                                                          
                                                                                                                          	// An identifier that was returned from the previous call to this operation, which
                                                                                                                          	// you can use to return the next set of items in the list.
                                                                                                                          	NextToken *string
                                                                                                                          }

                                                                                                                          type ListResolversByFunctionOutput

                                                                                                                          type ListResolversByFunctionOutput struct {
                                                                                                                          
                                                                                                                          	// An identifier that can be used to return the next set of items in the list.
                                                                                                                          	NextToken *string
                                                                                                                          
                                                                                                                          	// The list of resolvers.
                                                                                                                          	Resolvers []types.Resolver
                                                                                                                          
                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                          }

                                                                                                                          type ListResolversInput

                                                                                                                          type ListResolversInput struct {
                                                                                                                          
                                                                                                                          	// The API ID.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	ApiId *string
                                                                                                                          
                                                                                                                          	// The type name.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	TypeName *string
                                                                                                                          
                                                                                                                          	// The maximum number of results you want the request to return.
                                                                                                                          	MaxResults int32
                                                                                                                          
                                                                                                                          	// An identifier that was returned from the previous call to this operation, which
                                                                                                                          	// can be used to return the next set of items in the list.
                                                                                                                          	NextToken *string
                                                                                                                          }

                                                                                                                          type ListResolversOutput

                                                                                                                          type ListResolversOutput struct {
                                                                                                                          
                                                                                                                          	// An identifier to be passed in the next request to this operation to return the
                                                                                                                          	// next set of items in the list.
                                                                                                                          	NextToken *string
                                                                                                                          
                                                                                                                          	// The Resolver objects.
                                                                                                                          	Resolvers []types.Resolver
                                                                                                                          
                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                          }

                                                                                                                          type ListTagsForResourceInput

                                                                                                                          type ListTagsForResourceInput struct {
                                                                                                                          
                                                                                                                          	// The GraphqlApi ARN.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	ResourceArn *string
                                                                                                                          }

                                                                                                                          type ListTagsForResourceOutput

                                                                                                                          type ListTagsForResourceOutput struct {
                                                                                                                          
                                                                                                                          	// A TagMap object.
                                                                                                                          	Tags map[string]string
                                                                                                                          
                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                          }

                                                                                                                          type ListTypesInput

                                                                                                                          type ListTypesInput struct {
                                                                                                                          
                                                                                                                          	// The API ID.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	ApiId *string
                                                                                                                          
                                                                                                                          	// The type format: SDL or JSON.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	Format types.TypeDefinitionFormat
                                                                                                                          
                                                                                                                          	// The maximum number of results you want the request to return.
                                                                                                                          	MaxResults int32
                                                                                                                          
                                                                                                                          	// An identifier that was returned from the previous call to this operation, which
                                                                                                                          	// can be used to return the next set of items in the list.
                                                                                                                          	NextToken *string
                                                                                                                          }

                                                                                                                          type ListTypesOutput

                                                                                                                          type ListTypesOutput struct {
                                                                                                                          
                                                                                                                          	// An identifier to be passed in the next request to this operation to return the
                                                                                                                          	// next set of items in the list.
                                                                                                                          	NextToken *string
                                                                                                                          
                                                                                                                          	// The Type objects.
                                                                                                                          	Types []types.Type
                                                                                                                          
                                                                                                                          	// 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 StartSchemaCreationInput

                                                                                                                            type StartSchemaCreationInput struct {
                                                                                                                            
                                                                                                                            	// The API ID.
                                                                                                                            	//
                                                                                                                            	// This member is required.
                                                                                                                            	ApiId *string
                                                                                                                            
                                                                                                                            	// The schema definition, in GraphQL schema language format.
                                                                                                                            	//
                                                                                                                            	// This member is required.
                                                                                                                            	Definition []byte
                                                                                                                            }

                                                                                                                            type StartSchemaCreationOutput

                                                                                                                            type StartSchemaCreationOutput struct {
                                                                                                                            
                                                                                                                            	// The current state of the schema (PROCESSING, FAILED, SUCCESS, or
                                                                                                                            	// NOT_APPLICABLE). When the schema is in the ACTIVE state, you can add data.
                                                                                                                            	Status types.SchemaStatus
                                                                                                                            
                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                            }

                                                                                                                            type TagResourceInput

                                                                                                                            type TagResourceInput struct {
                                                                                                                            
                                                                                                                            	// The GraphqlApi ARN.
                                                                                                                            	//
                                                                                                                            	// This member is required.
                                                                                                                            	ResourceArn *string
                                                                                                                            
                                                                                                                            	// A TagMap object.
                                                                                                                            	//
                                                                                                                            	// 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 GraphqlApi ARN.
                                                                                                                            	//
                                                                                                                            	// This member is required.
                                                                                                                            	ResourceArn *string
                                                                                                                            
                                                                                                                            	// A list of TagKey objects.
                                                                                                                            	//
                                                                                                                            	// This member is required.
                                                                                                                            	TagKeys []string
                                                                                                                            }

                                                                                                                            type UntagResourceOutput

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

                                                                                                                            type UpdateApiCacheInput

                                                                                                                            type UpdateApiCacheInput struct {
                                                                                                                            
                                                                                                                            	// Caching behavior.
                                                                                                                            	//
                                                                                                                            	// * FULL_REQUEST_CACHING: All requests are fully cached.
                                                                                                                            	//
                                                                                                                            	// *
                                                                                                                            	// PER_RESOLVER_CACHING: Individual resolvers that you specify are cached.
                                                                                                                            	//
                                                                                                                            	// This member is required.
                                                                                                                            	ApiCachingBehavior types.ApiCachingBehavior
                                                                                                                            
                                                                                                                            	// The GraphQL API Id.
                                                                                                                            	//
                                                                                                                            	// This member is required.
                                                                                                                            	ApiId *string
                                                                                                                            
                                                                                                                            	// TTL in seconds for cache entries. Valid values are between 1 and 3600 seconds.
                                                                                                                            	//
                                                                                                                            	// This member is required.
                                                                                                                            	Ttl int64
                                                                                                                            
                                                                                                                            	// The cache instance type. Valid values are
                                                                                                                            	//
                                                                                                                            	// * SMALL
                                                                                                                            	//
                                                                                                                            	// * MEDIUM
                                                                                                                            	//
                                                                                                                            	// * LARGE
                                                                                                                            	//
                                                                                                                            	// *
                                                                                                                            	// XLARGE
                                                                                                                            	//
                                                                                                                            	// * LARGE_2X
                                                                                                                            	//
                                                                                                                            	// * LARGE_4X
                                                                                                                            	//
                                                                                                                            	// * LARGE_8X (not available in all regions)
                                                                                                                            	//
                                                                                                                            	// *
                                                                                                                            	// LARGE_12X
                                                                                                                            	//
                                                                                                                            	// Historically, instance types were identified by an EC2-style value.
                                                                                                                            	// As of July 2020, this is deprecated, and the generic identifiers above should be
                                                                                                                            	// used. The following legacy instance types are available, but their use is
                                                                                                                            	// discouraged:
                                                                                                                            	//
                                                                                                                            	// * T2_SMALL: A t2.small instance type.
                                                                                                                            	//
                                                                                                                            	// * T2_MEDIUM: A t2.medium
                                                                                                                            	// instance type.
                                                                                                                            	//
                                                                                                                            	// * R4_LARGE: A r4.large instance type.
                                                                                                                            	//
                                                                                                                            	// * R4_XLARGE: A r4.xlarge
                                                                                                                            	// instance type.
                                                                                                                            	//
                                                                                                                            	// * R4_2XLARGE: A r4.2xlarge instance type.
                                                                                                                            	//
                                                                                                                            	// * R4_4XLARGE: A
                                                                                                                            	// r4.4xlarge instance type.
                                                                                                                            	//
                                                                                                                            	// * R4_8XLARGE: A r4.8xlarge instance type.
                                                                                                                            	//
                                                                                                                            	// This member is required.
                                                                                                                            	Type types.ApiCacheType
                                                                                                                            }

                                                                                                                              Represents the input of a UpdateApiCache operation.

                                                                                                                              type UpdateApiCacheOutput

                                                                                                                              type UpdateApiCacheOutput struct {
                                                                                                                              
                                                                                                                              	// The ApiCache object.
                                                                                                                              	ApiCache *types.ApiCache
                                                                                                                              
                                                                                                                              	// Metadata pertaining to the operation's result.
                                                                                                                              	ResultMetadata middleware.Metadata
                                                                                                                              }

                                                                                                                                Represents the output of a UpdateApiCache operation.

                                                                                                                                type UpdateApiKeyInput

                                                                                                                                type UpdateApiKeyInput struct {
                                                                                                                                
                                                                                                                                	// The ID for the GraphQL API.
                                                                                                                                	//
                                                                                                                                	// This member is required.
                                                                                                                                	ApiId *string
                                                                                                                                
                                                                                                                                	// The API key ID.
                                                                                                                                	//
                                                                                                                                	// This member is required.
                                                                                                                                	Id *string
                                                                                                                                
                                                                                                                                	// A description of the purpose of the API key.
                                                                                                                                	Description *string
                                                                                                                                
                                                                                                                                	// The time from update time after which the API key expires. The date is
                                                                                                                                	// represented as seconds since the epoch. For more information, see .
                                                                                                                                	Expires int64
                                                                                                                                }

                                                                                                                                type UpdateApiKeyOutput

                                                                                                                                type UpdateApiKeyOutput struct {
                                                                                                                                
                                                                                                                                	// The API key.
                                                                                                                                	ApiKey *types.ApiKey
                                                                                                                                
                                                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                                                	ResultMetadata middleware.Metadata
                                                                                                                                }

                                                                                                                                type UpdateDataSourceInput

                                                                                                                                type UpdateDataSourceInput struct {
                                                                                                                                
                                                                                                                                	// The API ID.
                                                                                                                                	//
                                                                                                                                	// This member is required.
                                                                                                                                	ApiId *string
                                                                                                                                
                                                                                                                                	// The new name for the data source.
                                                                                                                                	//
                                                                                                                                	// This member is required.
                                                                                                                                	Name *string
                                                                                                                                
                                                                                                                                	// The new data source type.
                                                                                                                                	//
                                                                                                                                	// This member is required.
                                                                                                                                	Type types.DataSourceType
                                                                                                                                
                                                                                                                                	// The new description for the data source.
                                                                                                                                	Description *string
                                                                                                                                
                                                                                                                                	// The new Amazon DynamoDB configuration.
                                                                                                                                	DynamodbConfig *types.DynamodbDataSourceConfig
                                                                                                                                
                                                                                                                                	// The new Elasticsearch Service configuration.
                                                                                                                                	ElasticsearchConfig *types.ElasticsearchDataSourceConfig
                                                                                                                                
                                                                                                                                	// The new HTTP endpoint configuration.
                                                                                                                                	HttpConfig *types.HttpDataSourceConfig
                                                                                                                                
                                                                                                                                	// The new AWS Lambda configuration.
                                                                                                                                	LambdaConfig *types.LambdaDataSourceConfig
                                                                                                                                
                                                                                                                                	// The new relational database configuration.
                                                                                                                                	RelationalDatabaseConfig *types.RelationalDatabaseDataSourceConfig
                                                                                                                                
                                                                                                                                	// The new service role ARN for the data source.
                                                                                                                                	ServiceRoleArn *string
                                                                                                                                }

                                                                                                                                type UpdateDataSourceOutput

                                                                                                                                type UpdateDataSourceOutput struct {
                                                                                                                                
                                                                                                                                	// The updated DataSource object.
                                                                                                                                	DataSource *types.DataSource
                                                                                                                                
                                                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                                                	ResultMetadata middleware.Metadata
                                                                                                                                }

                                                                                                                                type UpdateFunctionInput

                                                                                                                                type UpdateFunctionInput struct {
                                                                                                                                
                                                                                                                                	// The GraphQL API ID.
                                                                                                                                	//
                                                                                                                                	// This member is required.
                                                                                                                                	ApiId *string
                                                                                                                                
                                                                                                                                	// The FunctionDataSource name.
                                                                                                                                	//
                                                                                                                                	// This member is required.
                                                                                                                                	DataSourceName *string
                                                                                                                                
                                                                                                                                	// The function ID.
                                                                                                                                	//
                                                                                                                                	// This member is required.
                                                                                                                                	FunctionId *string
                                                                                                                                
                                                                                                                                	// The version of the request mapping template. Currently the supported value is
                                                                                                                                	// 2018-05-29.
                                                                                                                                	//
                                                                                                                                	// This member is required.
                                                                                                                                	FunctionVersion *string
                                                                                                                                
                                                                                                                                	// The Function name.
                                                                                                                                	//
                                                                                                                                	// This member is required.
                                                                                                                                	Name *string
                                                                                                                                
                                                                                                                                	// The Function description.
                                                                                                                                	Description *string
                                                                                                                                
                                                                                                                                	// The Function request mapping template. Functions support only the 2018-05-29
                                                                                                                                	// version of the request mapping template.
                                                                                                                                	RequestMappingTemplate *string
                                                                                                                                
                                                                                                                                	// The Function request mapping template.
                                                                                                                                	ResponseMappingTemplate *string
                                                                                                                                }

                                                                                                                                type UpdateFunctionOutput

                                                                                                                                type UpdateFunctionOutput struct {
                                                                                                                                
                                                                                                                                	// The Function object.
                                                                                                                                	FunctionConfiguration *types.FunctionConfiguration
                                                                                                                                
                                                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                                                	ResultMetadata middleware.Metadata
                                                                                                                                }

                                                                                                                                type UpdateGraphqlApiInput

                                                                                                                                type UpdateGraphqlApiInput struct {
                                                                                                                                
                                                                                                                                	// The API ID.
                                                                                                                                	//
                                                                                                                                	// This member is required.
                                                                                                                                	ApiId *string
                                                                                                                                
                                                                                                                                	// The new name for the GraphqlApi object.
                                                                                                                                	//
                                                                                                                                	// This member is required.
                                                                                                                                	Name *string
                                                                                                                                
                                                                                                                                	// A list of additional authentication providers for the GraphqlApi API.
                                                                                                                                	AdditionalAuthenticationProviders []types.AdditionalAuthenticationProvider
                                                                                                                                
                                                                                                                                	// The new authentication type for the GraphqlApi object.
                                                                                                                                	AuthenticationType types.AuthenticationType
                                                                                                                                
                                                                                                                                	// The Amazon CloudWatch Logs configuration for the GraphqlApi object.
                                                                                                                                	LogConfig *types.LogConfig
                                                                                                                                
                                                                                                                                	// The OpenID Connect configuration for the GraphqlApi object.
                                                                                                                                	OpenIDConnectConfig *types.OpenIDConnectConfig
                                                                                                                                
                                                                                                                                	// The new Amazon Cognito user pool configuration for the GraphqlApi object.
                                                                                                                                	UserPoolConfig *types.UserPoolConfig
                                                                                                                                
                                                                                                                                	// A flag indicating whether to enable X-Ray tracing for the GraphqlApi.
                                                                                                                                	XrayEnabled bool
                                                                                                                                }

                                                                                                                                type UpdateGraphqlApiOutput

                                                                                                                                type UpdateGraphqlApiOutput struct {
                                                                                                                                
                                                                                                                                	// The updated GraphqlApi object.
                                                                                                                                	GraphqlApi *types.GraphqlApi
                                                                                                                                
                                                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                                                	ResultMetadata middleware.Metadata
                                                                                                                                }

                                                                                                                                type UpdateResolverInput

                                                                                                                                type UpdateResolverInput struct {
                                                                                                                                
                                                                                                                                	// The API ID.
                                                                                                                                	//
                                                                                                                                	// This member is required.
                                                                                                                                	ApiId *string
                                                                                                                                
                                                                                                                                	// The new field name.
                                                                                                                                	//
                                                                                                                                	// This member is required.
                                                                                                                                	FieldName *string
                                                                                                                                
                                                                                                                                	// The new type name.
                                                                                                                                	//
                                                                                                                                	// This member is required.
                                                                                                                                	TypeName *string
                                                                                                                                
                                                                                                                                	// The caching configuration for the resolver.
                                                                                                                                	CachingConfig *types.CachingConfig
                                                                                                                                
                                                                                                                                	// The new data source name.
                                                                                                                                	DataSourceName *string
                                                                                                                                
                                                                                                                                	// The resolver type.
                                                                                                                                	//
                                                                                                                                	// * UNIT: A UNIT resolver type. A UNIT resolver is the default
                                                                                                                                	// resolver type. A UNIT resolver enables you to execute a GraphQL query against a
                                                                                                                                	// single data source.
                                                                                                                                	//
                                                                                                                                	// * PIPELINE: A PIPELINE resolver type. A PIPELINE resolver
                                                                                                                                	// enables you to execute a series of Function in a serial manner. You can use a
                                                                                                                                	// pipeline resolver to execute a GraphQL query against multiple data sources.
                                                                                                                                	Kind types.ResolverKind
                                                                                                                                
                                                                                                                                	// The PipelineConfig.
                                                                                                                                	PipelineConfig *types.PipelineConfig
                                                                                                                                
                                                                                                                                	// The new request mapping template. A resolver uses a request mapping template to
                                                                                                                                	// convert a GraphQL expression into a format that a data source can understand.
                                                                                                                                	// Mapping templates are written in Apache Velocity Template Language (VTL). VTL
                                                                                                                                	// request mapping templates are optional when using a Lambda data source. For all
                                                                                                                                	// other data sources, VTL request and response mapping templates are required.
                                                                                                                                	RequestMappingTemplate *string
                                                                                                                                
                                                                                                                                	// The new response mapping template.
                                                                                                                                	ResponseMappingTemplate *string
                                                                                                                                
                                                                                                                                	// The SyncConfig for a resolver attached to a versioned datasource.
                                                                                                                                	SyncConfig *types.SyncConfig
                                                                                                                                }

                                                                                                                                type UpdateResolverOutput

                                                                                                                                type UpdateResolverOutput struct {
                                                                                                                                
                                                                                                                                	// The updated Resolver object.
                                                                                                                                	Resolver *types.Resolver
                                                                                                                                
                                                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                                                	ResultMetadata middleware.Metadata
                                                                                                                                }

                                                                                                                                type UpdateTypeInput

                                                                                                                                type UpdateTypeInput struct {
                                                                                                                                
                                                                                                                                	// The API ID.
                                                                                                                                	//
                                                                                                                                	// This member is required.
                                                                                                                                	ApiId *string
                                                                                                                                
                                                                                                                                	// The new type format: SDL or JSON.
                                                                                                                                	//
                                                                                                                                	// This member is required.
                                                                                                                                	Format types.TypeDefinitionFormat
                                                                                                                                
                                                                                                                                	// The new type name.
                                                                                                                                	//
                                                                                                                                	// This member is required.
                                                                                                                                	TypeName *string
                                                                                                                                
                                                                                                                                	// The new definition.
                                                                                                                                	Definition *string
                                                                                                                                }

                                                                                                                                type UpdateTypeOutput

                                                                                                                                type UpdateTypeOutput struct {
                                                                                                                                
                                                                                                                                	// The updated Type object.
                                                                                                                                	Type *types.Type
                                                                                                                                
                                                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                                                	ResultMetadata middleware.Metadata
                                                                                                                                }

                                                                                                                                Directories

                                                                                                                                Path Synopsis
                                                                                                                                internal