Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccessDeniedException

type AccessDeniedException struct {
	Message *string
}

    You do not have access to perform this operation on this resource.

    func (*AccessDeniedException) Error

    func (e *AccessDeniedException) Error() string

    func (*AccessDeniedException) ErrorCode

    func (e *AccessDeniedException) ErrorCode() string

    func (*AccessDeniedException) ErrorFault

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

    func (*AccessDeniedException) ErrorMessage

    func (e *AccessDeniedException) ErrorMessage() string

    type AdditionalAuthenticationProvider

    type AdditionalAuthenticationProvider struct {
    
    	// The authentication type: API key, AWS IAM, OIDC, or Amazon Cognito user pools.
    	AuthenticationType AuthenticationType
    
    	// The OpenID Connect configuration.
    	OpenIDConnectConfig *OpenIDConnectConfig
    
    	// The Amazon Cognito user pool configuration.
    	UserPoolConfig *CognitoUserPoolConfig
    }

      Describes an additional authentication provider.

      type ApiCache

      type ApiCache struct {
      
      	// Caching behavior.
      	//
      	// * FULL_REQUEST_CACHING: All requests are fully cached.
      	//
      	// *
      	// PER_RESOLVER_CACHING: Individual resolvers that you specify are cached.
      	ApiCachingBehavior ApiCachingBehavior
      
      	// At rest encryption flag for cache. This setting cannot be updated after
      	// creation.
      	AtRestEncryptionEnabled bool
      
      	// The cache instance status.
      	//
      	// * AVAILABLE: The instance is available for use.
      	//
      	// *
      	// CREATING: The instance is currently creating.
      	//
      	// * DELETING: The instance is
      	// currently deleting.
      	//
      	// * MODIFYING: The instance is currently modifying.
      	//
      	// *
      	// FAILED: The instance has failed creation.
      	Status ApiCacheStatus
      
      	// Transit encryption flag when connecting to cache. This setting cannot be updated
      	// after creation.
      	TransitEncryptionEnabled bool
      
      	// TTL in seconds for cache entries. Valid values are between 1 and 3600 seconds.
      	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.
      	Type ApiCacheType
      }

        The ApiCache object.

        type ApiCacheStatus

        type ApiCacheStatus string
        const (
        	ApiCacheStatusAvailable ApiCacheStatus = "AVAILABLE"
        	ApiCacheStatusCreating  ApiCacheStatus = "CREATING"
        	ApiCacheStatusDeleting  ApiCacheStatus = "DELETING"
        	ApiCacheStatusModifying ApiCacheStatus = "MODIFYING"
        	ApiCacheStatusFailed    ApiCacheStatus = "FAILED"
        )

          Enum values for ApiCacheStatus

          func (ApiCacheStatus) Values

          func (ApiCacheStatus) Values() []ApiCacheStatus

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

            type ApiCacheType

            type ApiCacheType string
            const (
            	ApiCacheTypeT2Small   ApiCacheType = "T2_SMALL"
            	ApiCacheTypeT2Medium  ApiCacheType = "T2_MEDIUM"
            	ApiCacheTypeR4Large   ApiCacheType = "R4_LARGE"
            	ApiCacheTypeR4Xlarge  ApiCacheType = "R4_XLARGE"
            	ApiCacheTypeR42xlarge ApiCacheType = "R4_2XLARGE"
            	ApiCacheTypeR44xlarge ApiCacheType = "R4_4XLARGE"
            	ApiCacheTypeR48xlarge ApiCacheType = "R4_8XLARGE"
            	ApiCacheTypeSmall     ApiCacheType = "SMALL"
            	ApiCacheTypeMedium    ApiCacheType = "MEDIUM"
            	ApiCacheTypeLarge     ApiCacheType = "LARGE"
            	ApiCacheTypeXlarge    ApiCacheType = "XLARGE"
            	ApiCacheTypeLarge2x   ApiCacheType = "LARGE_2X"
            	ApiCacheTypeLarge4x   ApiCacheType = "LARGE_4X"
            	ApiCacheTypeLarge8x   ApiCacheType = "LARGE_8X"
            	ApiCacheTypeLarge12x  ApiCacheType = "LARGE_12X"
            )

              Enum values for ApiCacheType

              func (ApiCacheType) Values

              func (ApiCacheType) Values() []ApiCacheType

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

                type ApiCachingBehavior

                type ApiCachingBehavior string
                const (
                	ApiCachingBehaviorFullRequestCaching ApiCachingBehavior = "FULL_REQUEST_CACHING"
                	ApiCachingBehaviorPerResolverCaching ApiCachingBehavior = "PER_RESOLVER_CACHING"
                )

                  Enum values for ApiCachingBehavior

                  func (ApiCachingBehavior) Values

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

                    type ApiKey

                    type ApiKey struct {
                    
                    	// The time after which the API key is deleted. The date is represented as seconds
                    	// since the epoch, rounded down to the nearest hour.
                    	Deletes int64
                    
                    	// A description of the purpose of the API key.
                    	Description *string
                    
                    	// The time after which the API key expires. The date is represented as seconds
                    	// since the epoch, rounded down to the nearest hour.
                    	Expires int64
                    
                    	// The API key ID.
                    	Id *string
                    }

                      Describes an API key. Customers invoke AWS AppSync GraphQL API operations with API keys as an identity mechanism. There are two key versions: da1: This version was introduced at launch in November 2017. These keys always expire after 7 days. Key expiration is managed by Amazon DynamoDB TTL. The keys ceased to be valid after February 21, 2018 and should not be used after that date.

                      * ListApiKeys returns the expiration time in milliseconds.

                      * CreateApiKey returns the expiration time in milliseconds.

                      * UpdateApiKey is not available for this key version.

                      * DeleteApiKey deletes the item from the table.

                      * Expiration is stored in Amazon DynamoDB as milliseconds. This results in a bug where keys are not automatically deleted because DynamoDB expects the TTL to be stored in seconds. As a one-time action, we will delete these keys from the table after February 21, 2018.

                      da2: This version was introduced in February 2018 when AppSync added support to extend key expiration.

                      * ListApiKeys returns the expiration time and deletion time in seconds.

                      * CreateApiKey returns the expiration time and deletion time in seconds and accepts a user-provided expiration time in seconds.

                      * UpdateApiKey returns the expiration time and and deletion time in seconds and accepts a user-provided expiration time in seconds. Expired API keys are kept for 60 days after the expiration time. Key expiration time can be updated while the key is not deleted.

                      * DeleteApiKey deletes the item from the table.

                      * Expiration is stored in Amazon DynamoDB as seconds. After the expiration time, using the key to authenticate will fail. But the key can be reinstated before deletion.

                      * Deletion is stored in Amazon DynamoDB as seconds. The key will be deleted after deletion time.

                      type ApiKeyLimitExceededException

                      type ApiKeyLimitExceededException struct {
                      	Message *string
                      }

                        The API key exceeded a limit. Try your request again.

                        func (*ApiKeyLimitExceededException) Error

                        func (*ApiKeyLimitExceededException) ErrorCode

                        func (e *ApiKeyLimitExceededException) ErrorCode() string

                        func (*ApiKeyLimitExceededException) ErrorFault

                        func (*ApiKeyLimitExceededException) ErrorMessage

                        func (e *ApiKeyLimitExceededException) ErrorMessage() string

                        type ApiKeyValidityOutOfBoundsException

                        type ApiKeyValidityOutOfBoundsException struct {
                        	Message *string
                        }

                          The API key expiration must be set to a value between 1 and 365 days from creation (for CreateApiKey) or from update (for UpdateApiKey).

                          func (*ApiKeyValidityOutOfBoundsException) Error

                          func (*ApiKeyValidityOutOfBoundsException) ErrorCode

                          func (*ApiKeyValidityOutOfBoundsException) ErrorFault

                          func (*ApiKeyValidityOutOfBoundsException) ErrorMessage

                          func (e *ApiKeyValidityOutOfBoundsException) ErrorMessage() string

                          type ApiLimitExceededException

                          type ApiLimitExceededException struct {
                          	Message *string
                          }

                            The GraphQL API exceeded a limit. Try your request again.

                            func (*ApiLimitExceededException) Error

                            func (e *ApiLimitExceededException) Error() string

                            func (*ApiLimitExceededException) ErrorCode

                            func (e *ApiLimitExceededException) ErrorCode() string

                            func (*ApiLimitExceededException) ErrorFault

                            func (*ApiLimitExceededException) ErrorMessage

                            func (e *ApiLimitExceededException) ErrorMessage() string

                            type AuthenticationType

                            type AuthenticationType string
                            const (
                            	AuthenticationTypeApiKey                 AuthenticationType = "API_KEY"
                            	AuthenticationTypeAwsIam                 AuthenticationType = "AWS_IAM"
                            	AuthenticationTypeAmazonCognitoUserPools AuthenticationType = "AMAZON_COGNITO_USER_POOLS"
                            	AuthenticationTypeOpenidConnect          AuthenticationType = "OPENID_CONNECT"
                            )

                              Enum values for AuthenticationType

                              func (AuthenticationType) Values

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

                                type AuthorizationConfig

                                type AuthorizationConfig struct {
                                
                                	// The authorization type required by the HTTP endpoint.
                                	//
                                	// * AWS_IAM: The
                                	// authorization type is Sigv4.
                                	//
                                	// This member is required.
                                	AuthorizationType AuthorizationType
                                
                                	// The AWS IAM settings.
                                	AwsIamConfig *AwsIamConfig
                                }

                                  The authorization config in case the HTTP endpoint requires authorization.

                                  type AuthorizationType

                                  type AuthorizationType string
                                  const (
                                  	AuthorizationTypeAwsIam AuthorizationType = "AWS_IAM"
                                  )

                                    Enum values for AuthorizationType

                                    func (AuthorizationType) Values

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

                                      type AwsIamConfig

                                      type AwsIamConfig struct {
                                      
                                      	// The signing region for AWS IAM authorization.
                                      	SigningRegion *string
                                      
                                      	// The signing service name for AWS IAM authorization.
                                      	SigningServiceName *string
                                      }

                                        The AWS IAM configuration.

                                        type BadRequestException

                                        type BadRequestException struct {
                                        	Message *string
                                        }

                                          The request is not well formed. For example, a value is invalid or a required field is missing. Check the field values, and then try again.

                                          func (*BadRequestException) Error

                                          func (e *BadRequestException) Error() string

                                          func (*BadRequestException) ErrorCode

                                          func (e *BadRequestException) ErrorCode() string

                                          func (*BadRequestException) ErrorFault

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

                                          func (*BadRequestException) ErrorMessage

                                          func (e *BadRequestException) ErrorMessage() string

                                          type CachingConfig

                                          type CachingConfig struct {
                                          
                                          	// The caching keys for a resolver that has caching enabled. Valid values are
                                          	// entries from the $context.arguments, $context.source, and $context.identity
                                          	// maps.
                                          	CachingKeys []string
                                          
                                          	// The TTL in seconds for a resolver that has caching enabled. Valid values are
                                          	// between 1 and 3600 seconds.
                                          	Ttl int64
                                          }

                                            The caching configuration for a resolver that has caching enabled.

                                            type CognitoUserPoolConfig

                                            type CognitoUserPoolConfig struct {
                                            
                                            	// The AWS Region in which the user pool was created.
                                            	//
                                            	// This member is required.
                                            	AwsRegion *string
                                            
                                            	// The user pool ID.
                                            	//
                                            	// This member is required.
                                            	UserPoolId *string
                                            
                                            	// A regular expression for validating the incoming Amazon Cognito user pool app
                                            	// client ID.
                                            	AppIdClientRegex *string
                                            }

                                              Describes an Amazon Cognito user pool configuration.

                                              type ConcurrentModificationException

                                              type ConcurrentModificationException struct {
                                              	Message *string
                                              }

                                                Another modification is in progress at this time and it must complete before you can make your change.

                                                func (*ConcurrentModificationException) Error

                                                func (*ConcurrentModificationException) ErrorCode

                                                func (e *ConcurrentModificationException) ErrorCode() string

                                                func (*ConcurrentModificationException) ErrorFault

                                                func (*ConcurrentModificationException) ErrorMessage

                                                func (e *ConcurrentModificationException) ErrorMessage() string

                                                type ConflictDetectionType

                                                type ConflictDetectionType string
                                                const (
                                                	ConflictDetectionTypeVersion ConflictDetectionType = "VERSION"
                                                	ConflictDetectionTypeNone    ConflictDetectionType = "NONE"
                                                )

                                                  Enum values for ConflictDetectionType

                                                  func (ConflictDetectionType) Values

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

                                                    type ConflictHandlerType

                                                    type ConflictHandlerType string
                                                    const (
                                                    	ConflictHandlerTypeOptimisticConcurrency ConflictHandlerType = "OPTIMISTIC_CONCURRENCY"
                                                    	ConflictHandlerTypeLambda                ConflictHandlerType = "LAMBDA"
                                                    	ConflictHandlerTypeAutomerge             ConflictHandlerType = "AUTOMERGE"
                                                    	ConflictHandlerTypeNone                  ConflictHandlerType = "NONE"
                                                    )

                                                      Enum values for ConflictHandlerType

                                                      func (ConflictHandlerType) Values

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

                                                        type DataSource

                                                        type DataSource struct {
                                                        
                                                        	// The data source ARN.
                                                        	DataSourceArn *string
                                                        
                                                        	// The description of the data source.
                                                        	Description *string
                                                        
                                                        	// Amazon DynamoDB settings.
                                                        	DynamodbConfig *DynamodbDataSourceConfig
                                                        
                                                        	// Amazon Elasticsearch Service settings.
                                                        	ElasticsearchConfig *ElasticsearchDataSourceConfig
                                                        
                                                        	// HTTP endpoint settings.
                                                        	HttpConfig *HttpDataSourceConfig
                                                        
                                                        	// AWS Lambda settings.
                                                        	LambdaConfig *LambdaDataSourceConfig
                                                        
                                                        	// The name of the data source.
                                                        	Name *string
                                                        
                                                        	// Relational database settings.
                                                        	RelationalDatabaseConfig *RelationalDatabaseDataSourceConfig
                                                        
                                                        	// The AWS IAM service role ARN for the data source. The system assumes this role
                                                        	// when accessing the data source.
                                                        	ServiceRoleArn *string
                                                        
                                                        	// The type of the data source.
                                                        	//
                                                        	// * AMAZON_DYNAMODB: The data source is an Amazon
                                                        	// DynamoDB table.
                                                        	//
                                                        	// * AMAZON_ELASTICSEARCH: The data source is an Amazon
                                                        	// Elasticsearch Service domain.
                                                        	//
                                                        	// * AWS_LAMBDA: The data source is an AWS Lambda
                                                        	// function.
                                                        	//
                                                        	// * NONE: There is no data source. This type is used when you wish to
                                                        	// invoke a GraphQL operation without connecting to a data source, such as
                                                        	// performing data transformation with resolvers or triggering a subscription to be
                                                        	// invoked from a mutation.
                                                        	//
                                                        	// * HTTP: The data source is an HTTP endpoint.
                                                        	//
                                                        	// *
                                                        	// RELATIONAL_DATABASE: The data source is a relational database.
                                                        	Type DataSourceType
                                                        }

                                                          Describes a data source.

                                                          type DataSourceType

                                                          type DataSourceType string
                                                          const (
                                                          	DataSourceTypeAwsLambda           DataSourceType = "AWS_LAMBDA"
                                                          	DataSourceTypeAmazonDynamodb      DataSourceType = "AMAZON_DYNAMODB"
                                                          	DataSourceTypeAmazonElasticsearch DataSourceType = "AMAZON_ELASTICSEARCH"
                                                          	DataSourceTypeNone                DataSourceType = "NONE"
                                                          	DataSourceTypeHttp                DataSourceType = "HTTP"
                                                          	DataSourceTypeRelationalDatabase  DataSourceType = "RELATIONAL_DATABASE"
                                                          )

                                                            Enum values for DataSourceType

                                                            func (DataSourceType) Values

                                                            func (DataSourceType) Values() []DataSourceType

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

                                                              type DefaultAction

                                                              type DefaultAction string
                                                              const (
                                                              	DefaultActionAllow DefaultAction = "ALLOW"
                                                              	DefaultActionDeny  DefaultAction = "DENY"
                                                              )

                                                                Enum values for DefaultAction

                                                                func (DefaultAction) Values

                                                                func (DefaultAction) Values() []DefaultAction

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

                                                                  type DeltaSyncConfig

                                                                  type DeltaSyncConfig struct {
                                                                  
                                                                  	// The number of minutes an Item is stored in the datasource.
                                                                  	BaseTableTTL int64
                                                                  
                                                                  	// The Delta Sync table name.
                                                                  	DeltaSyncTableName *string
                                                                  
                                                                  	// The number of minutes a Delta Sync log entry is stored in the Delta Sync table.
                                                                  	DeltaSyncTableTTL int64
                                                                  }

                                                                    Describes a Delta Sync configuration.

                                                                    type DynamodbDataSourceConfig

                                                                    type DynamodbDataSourceConfig struct {
                                                                    
                                                                    	// The AWS Region.
                                                                    	//
                                                                    	// This member is required.
                                                                    	AwsRegion *string
                                                                    
                                                                    	// The table name.
                                                                    	//
                                                                    	// This member is required.
                                                                    	TableName *string
                                                                    
                                                                    	// The DeltaSyncConfig for a versioned datasource.
                                                                    	DeltaSyncConfig *DeltaSyncConfig
                                                                    
                                                                    	// Set to TRUE to use Amazon Cognito credentials with this data source.
                                                                    	UseCallerCredentials bool
                                                                    
                                                                    	// Set to TRUE to use Conflict Detection and Resolution with this data source.
                                                                    	Versioned bool
                                                                    }

                                                                      Describes an Amazon DynamoDB data source configuration.

                                                                      type ElasticsearchDataSourceConfig

                                                                      type ElasticsearchDataSourceConfig struct {
                                                                      
                                                                      	// The AWS Region.
                                                                      	//
                                                                      	// This member is required.
                                                                      	AwsRegion *string
                                                                      
                                                                      	// The endpoint.
                                                                      	//
                                                                      	// This member is required.
                                                                      	Endpoint *string
                                                                      }

                                                                        Describes an Elasticsearch data source configuration.

                                                                        type FieldLogLevel

                                                                        type FieldLogLevel string
                                                                        const (
                                                                        	FieldLogLevelNone  FieldLogLevel = "NONE"
                                                                        	FieldLogLevelError FieldLogLevel = "ERROR"
                                                                        	FieldLogLevelAll   FieldLogLevel = "ALL"
                                                                        )

                                                                          Enum values for FieldLogLevel

                                                                          func (FieldLogLevel) Values

                                                                          func (FieldLogLevel) Values() []FieldLogLevel

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

                                                                            type FunctionConfiguration

                                                                            type FunctionConfiguration struct {
                                                                            
                                                                            	// The name of the DataSource.
                                                                            	DataSourceName *string
                                                                            
                                                                            	// The Function description.
                                                                            	Description *string
                                                                            
                                                                            	// The ARN of the Function object.
                                                                            	FunctionArn *string
                                                                            
                                                                            	// A unique ID representing the Function object.
                                                                            	FunctionId *string
                                                                            
                                                                            	// The version of the request mapping template. Currently only the 2018-05-29
                                                                            	// version of the template is supported.
                                                                            	FunctionVersion *string
                                                                            
                                                                            	// The name of the Function object.
                                                                            	Name *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
                                                                            }

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

                                                                              type GraphQLSchemaException

                                                                              type GraphQLSchemaException struct {
                                                                              	Message *string
                                                                              }

                                                                                The GraphQL schema is not valid.

                                                                                func (*GraphQLSchemaException) Error

                                                                                func (e *GraphQLSchemaException) Error() string

                                                                                func (*GraphQLSchemaException) ErrorCode

                                                                                func (e *GraphQLSchemaException) ErrorCode() string

                                                                                func (*GraphQLSchemaException) ErrorFault

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

                                                                                func (*GraphQLSchemaException) ErrorMessage

                                                                                func (e *GraphQLSchemaException) ErrorMessage() string

                                                                                type GraphqlApi

                                                                                type GraphqlApi struct {
                                                                                
                                                                                	// A list of additional authentication providers for the GraphqlApi API.
                                                                                	AdditionalAuthenticationProviders []AdditionalAuthenticationProvider
                                                                                
                                                                                	// The API ID.
                                                                                	ApiId *string
                                                                                
                                                                                	// The ARN.
                                                                                	Arn *string
                                                                                
                                                                                	// The authentication type.
                                                                                	AuthenticationType AuthenticationType
                                                                                
                                                                                	// The Amazon CloudWatch Logs configuration.
                                                                                	LogConfig *LogConfig
                                                                                
                                                                                	// The API name.
                                                                                	Name *string
                                                                                
                                                                                	// The OpenID Connect configuration.
                                                                                	OpenIDConnectConfig *OpenIDConnectConfig
                                                                                
                                                                                	// The tags.
                                                                                	Tags map[string]string
                                                                                
                                                                                	// The URIs.
                                                                                	Uris map[string]string
                                                                                
                                                                                	// The Amazon Cognito user pool configuration.
                                                                                	UserPoolConfig *UserPoolConfig
                                                                                
                                                                                	// The ARN of the AWS Web Application Firewall (WAF) ACL associated with this
                                                                                	// GraphqlApi, if one exists.
                                                                                	WafWebAclArn *string
                                                                                
                                                                                	// A flag representing whether X-Ray tracing is enabled for this GraphqlApi.
                                                                                	XrayEnabled bool
                                                                                }

                                                                                  Describes a GraphQL API.

                                                                                  type HttpDataSourceConfig

                                                                                  type HttpDataSourceConfig struct {
                                                                                  
                                                                                  	// The authorization config in case the HTTP endpoint requires authorization.
                                                                                  	AuthorizationConfig *AuthorizationConfig
                                                                                  
                                                                                  	// The HTTP URL endpoint. You can either specify the domain name or IP, and port
                                                                                  	// combination, and the URL scheme must be HTTP or HTTPS. If the port is not
                                                                                  	// specified, AWS AppSync uses the default port 80 for the HTTP endpoint and port
                                                                                  	// 443 for HTTPS endpoints.
                                                                                  	Endpoint *string
                                                                                  }

                                                                                    Describes an HTTP data source configuration.

                                                                                    type InternalFailureException

                                                                                    type InternalFailureException struct {
                                                                                    	Message *string
                                                                                    }

                                                                                      An internal AWS AppSync error occurred. Try your request again.

                                                                                      func (*InternalFailureException) Error

                                                                                      func (e *InternalFailureException) Error() string

                                                                                      func (*InternalFailureException) ErrorCode

                                                                                      func (e *InternalFailureException) ErrorCode() string

                                                                                      func (*InternalFailureException) ErrorFault

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

                                                                                      func (*InternalFailureException) ErrorMessage

                                                                                      func (e *InternalFailureException) ErrorMessage() string

                                                                                      type LambdaConflictHandlerConfig

                                                                                      type LambdaConflictHandlerConfig struct {
                                                                                      
                                                                                      	// The Arn for the Lambda function to use as the Conflict Handler.
                                                                                      	LambdaConflictHandlerArn *string
                                                                                      }

                                                                                        The LambdaConflictHandlerConfig object when configuring LAMBDA as the Conflict Handler.

                                                                                        type LambdaDataSourceConfig

                                                                                        type LambdaDataSourceConfig struct {
                                                                                        
                                                                                        	// The ARN for the Lambda function.
                                                                                        	//
                                                                                        	// This member is required.
                                                                                        	LambdaFunctionArn *string
                                                                                        }

                                                                                          Describes an AWS Lambda data source configuration.

                                                                                          type LimitExceededException

                                                                                          type LimitExceededException struct {
                                                                                          	Message *string
                                                                                          }

                                                                                            The request exceeded a limit. Try your request again.

                                                                                            func (*LimitExceededException) Error

                                                                                            func (e *LimitExceededException) Error() string

                                                                                            func (*LimitExceededException) ErrorCode

                                                                                            func (e *LimitExceededException) ErrorCode() string

                                                                                            func (*LimitExceededException) ErrorFault

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

                                                                                            func (*LimitExceededException) ErrorMessage

                                                                                            func (e *LimitExceededException) ErrorMessage() string

                                                                                            type LogConfig

                                                                                            type LogConfig struct {
                                                                                            
                                                                                            	// The service role that AWS AppSync will assume to publish to Amazon CloudWatch
                                                                                            	// logs in your account.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	CloudWatchLogsRoleArn *string
                                                                                            
                                                                                            	// The field logging level. Values can be NONE, ERROR, or ALL.
                                                                                            	//
                                                                                            	// * NONE: No
                                                                                            	// field-level logs are captured.
                                                                                            	//
                                                                                            	// * ERROR: Logs the following information only for
                                                                                            	// the fields that are in error:
                                                                                            	//
                                                                                            	// * The error section in the server response.
                                                                                            	//
                                                                                            	// *
                                                                                            	// Field-level errors.
                                                                                            	//
                                                                                            	// * The generated request/response functions that got
                                                                                            	// resolved for error fields.
                                                                                            	//
                                                                                            	// * ALL: The following information is logged for all
                                                                                            	// fields in the query:
                                                                                            	//
                                                                                            	// * Field-level tracing information.
                                                                                            	//
                                                                                            	// * The generated
                                                                                            	// request/response functions that got resolved for each field.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	FieldLogLevel FieldLogLevel
                                                                                            
                                                                                            	// Set to TRUE to exclude sections that contain information such as headers,
                                                                                            	// context, and evaluated mapping templates, regardless of logging level.
                                                                                            	ExcludeVerboseContent bool
                                                                                            }

                                                                                              The CloudWatch Logs configuration.

                                                                                              type NotFoundException

                                                                                              type NotFoundException struct {
                                                                                              	Message *string
                                                                                              }

                                                                                                The resource specified in the request was not found. Check the resource, and then try again.

                                                                                                func (*NotFoundException) Error

                                                                                                func (e *NotFoundException) Error() string

                                                                                                func (*NotFoundException) ErrorCode

                                                                                                func (e *NotFoundException) ErrorCode() string

                                                                                                func (*NotFoundException) ErrorFault

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

                                                                                                func (*NotFoundException) ErrorMessage

                                                                                                func (e *NotFoundException) ErrorMessage() string

                                                                                                type OpenIDConnectConfig

                                                                                                type OpenIDConnectConfig struct {
                                                                                                
                                                                                                	// The issuer for the OpenID Connect configuration. The issuer returned by
                                                                                                	// discovery must exactly match the value of iss in the ID token.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Issuer *string
                                                                                                
                                                                                                	// The number of milliseconds a token is valid after being authenticated.
                                                                                                	AuthTTL int64
                                                                                                
                                                                                                	// The client identifier of the Relying party at the OpenID identity provider. This
                                                                                                	// identifier is typically obtained when the Relying party is registered with the
                                                                                                	// OpenID identity provider. You can specify a regular expression so the AWS
                                                                                                	// AppSync can validate against multiple client identifiers at a time.
                                                                                                	ClientId *string
                                                                                                
                                                                                                	// The number of milliseconds a token is valid after being issued to a user.
                                                                                                	IatTTL int64
                                                                                                }

                                                                                                  Describes an OpenID Connect configuration.

                                                                                                  type OutputType

                                                                                                  type OutputType string
                                                                                                  const (
                                                                                                  	OutputTypeSdl  OutputType = "SDL"
                                                                                                  	OutputTypeJson OutputType = "JSON"
                                                                                                  )

                                                                                                    Enum values for OutputType

                                                                                                    func (OutputType) Values

                                                                                                    func (OutputType) Values() []OutputType

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

                                                                                                      type PipelineConfig

                                                                                                      type PipelineConfig struct {
                                                                                                      
                                                                                                      	// A list of Function objects.
                                                                                                      	Functions []string
                                                                                                      }

                                                                                                        The pipeline configuration for a resolver of kind PIPELINE.

                                                                                                        type RdsHttpEndpointConfig

                                                                                                        type RdsHttpEndpointConfig struct {
                                                                                                        
                                                                                                        	// AWS Region for RDS HTTP endpoint.
                                                                                                        	AwsRegion *string
                                                                                                        
                                                                                                        	// AWS secret store ARN for database credentials.
                                                                                                        	AwsSecretStoreArn *string
                                                                                                        
                                                                                                        	// Logical database name.
                                                                                                        	DatabaseName *string
                                                                                                        
                                                                                                        	// Amazon RDS cluster ARN.
                                                                                                        	DbClusterIdentifier *string
                                                                                                        
                                                                                                        	// Logical schema name.
                                                                                                        	Schema *string
                                                                                                        }

                                                                                                          The Amazon RDS HTTP endpoint configuration.

                                                                                                          type RelationalDatabaseDataSourceConfig

                                                                                                          type RelationalDatabaseDataSourceConfig struct {
                                                                                                          
                                                                                                          	// Amazon RDS HTTP endpoint settings.
                                                                                                          	RdsHttpEndpointConfig *RdsHttpEndpointConfig
                                                                                                          
                                                                                                          	// Source type for the relational database.
                                                                                                          	//
                                                                                                          	// * RDS_HTTP_ENDPOINT: The relational
                                                                                                          	// database source type is an Amazon RDS HTTP endpoint.
                                                                                                          	RelationalDatabaseSourceType RelationalDatabaseSourceType
                                                                                                          }

                                                                                                            Describes a relational database data source configuration.

                                                                                                            type RelationalDatabaseSourceType

                                                                                                            type RelationalDatabaseSourceType string
                                                                                                            const (
                                                                                                            	RelationalDatabaseSourceTypeRdsHttpEndpoint RelationalDatabaseSourceType = "RDS_HTTP_ENDPOINT"
                                                                                                            )

                                                                                                              Enum values for RelationalDatabaseSourceType

                                                                                                              func (RelationalDatabaseSourceType) Values

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

                                                                                                                type Resolver

                                                                                                                type Resolver struct {
                                                                                                                
                                                                                                                	// The caching configuration for the resolver.
                                                                                                                	CachingConfig *CachingConfig
                                                                                                                
                                                                                                                	// The resolver data source name.
                                                                                                                	DataSourceName *string
                                                                                                                
                                                                                                                	// The resolver field name.
                                                                                                                	FieldName *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 ResolverKind
                                                                                                                
                                                                                                                	// The PipelineConfig.
                                                                                                                	PipelineConfig *PipelineConfig
                                                                                                                
                                                                                                                	// The request mapping template.
                                                                                                                	RequestMappingTemplate *string
                                                                                                                
                                                                                                                	// The resolver ARN.
                                                                                                                	ResolverArn *string
                                                                                                                
                                                                                                                	// The response mapping template.
                                                                                                                	ResponseMappingTemplate *string
                                                                                                                
                                                                                                                	// The SyncConfig for a resolver attached to a versioned datasource.
                                                                                                                	SyncConfig *SyncConfig
                                                                                                                
                                                                                                                	// The resolver type name.
                                                                                                                	TypeName *string
                                                                                                                }

                                                                                                                  Describes a resolver.

                                                                                                                  type ResolverKind

                                                                                                                  type ResolverKind string
                                                                                                                  const (
                                                                                                                  	ResolverKindUnit     ResolverKind = "UNIT"
                                                                                                                  	ResolverKindPipeline ResolverKind = "PIPELINE"
                                                                                                                  )

                                                                                                                    Enum values for ResolverKind

                                                                                                                    func (ResolverKind) Values

                                                                                                                    func (ResolverKind) Values() []ResolverKind

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

                                                                                                                      type SchemaStatus

                                                                                                                      type SchemaStatus string
                                                                                                                      const (
                                                                                                                      	SchemaStatusProcessing    SchemaStatus = "PROCESSING"
                                                                                                                      	SchemaStatusActive        SchemaStatus = "ACTIVE"
                                                                                                                      	SchemaStatusDeleting      SchemaStatus = "DELETING"
                                                                                                                      	SchemaStatusFailed        SchemaStatus = "FAILED"
                                                                                                                      	SchemaStatusSuccess       SchemaStatus = "SUCCESS"
                                                                                                                      	SchemaStatusNotApplicable SchemaStatus = "NOT_APPLICABLE"
                                                                                                                      )

                                                                                                                        Enum values for SchemaStatus

                                                                                                                        func (SchemaStatus) Values

                                                                                                                        func (SchemaStatus) Values() []SchemaStatus

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

                                                                                                                          type SyncConfig

                                                                                                                          type SyncConfig struct {
                                                                                                                          
                                                                                                                          	// The Conflict Detection strategy to use.
                                                                                                                          	//
                                                                                                                          	// * VERSION: Detect conflicts based on
                                                                                                                          	// object versions for this resolver.
                                                                                                                          	//
                                                                                                                          	// * NONE: Do not detect conflicts when
                                                                                                                          	// executing this resolver.
                                                                                                                          	ConflictDetection ConflictDetectionType
                                                                                                                          
                                                                                                                          	// The Conflict Resolution strategy to perform in the event of a conflict.
                                                                                                                          	//
                                                                                                                          	// *
                                                                                                                          	// OPTIMISTIC_CONCURRENCY: Resolve conflicts by rejecting mutations when versions
                                                                                                                          	// do not match the latest version at the server.
                                                                                                                          	//
                                                                                                                          	// * AUTOMERGE: Resolve conflicts
                                                                                                                          	// with the Automerge conflict resolution strategy.
                                                                                                                          	//
                                                                                                                          	// * LAMBDA: Resolve conflicts
                                                                                                                          	// with a Lambda function supplied in the LambdaConflictHandlerConfig.
                                                                                                                          	ConflictHandler ConflictHandlerType
                                                                                                                          
                                                                                                                          	// The LambdaConflictHandlerConfig when configuring LAMBDA as the Conflict Handler.
                                                                                                                          	LambdaConflictHandlerConfig *LambdaConflictHandlerConfig
                                                                                                                          }

                                                                                                                            Describes a Sync configuration for a resolver. Contains information on which Conflict Detection as well as Resolution strategy should be performed when the resolver is invoked.

                                                                                                                            type Type

                                                                                                                            type Type struct {
                                                                                                                            
                                                                                                                            	// The type ARN.
                                                                                                                            	Arn *string
                                                                                                                            
                                                                                                                            	// The type definition.
                                                                                                                            	Definition *string
                                                                                                                            
                                                                                                                            	// The type description.
                                                                                                                            	Description *string
                                                                                                                            
                                                                                                                            	// The type format: SDL or JSON.
                                                                                                                            	Format TypeDefinitionFormat
                                                                                                                            
                                                                                                                            	// The type name.
                                                                                                                            	Name *string
                                                                                                                            }

                                                                                                                              Describes a type.

                                                                                                                              type TypeDefinitionFormat

                                                                                                                              type TypeDefinitionFormat string
                                                                                                                              const (
                                                                                                                              	TypeDefinitionFormatSdl  TypeDefinitionFormat = "SDL"
                                                                                                                              	TypeDefinitionFormatJson TypeDefinitionFormat = "JSON"
                                                                                                                              )

                                                                                                                                Enum values for TypeDefinitionFormat

                                                                                                                                func (TypeDefinitionFormat) Values

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

                                                                                                                                  type UnauthorizedException

                                                                                                                                  type UnauthorizedException struct {
                                                                                                                                  	Message *string
                                                                                                                                  }

                                                                                                                                    You are not authorized to perform this operation.

                                                                                                                                    func (*UnauthorizedException) Error

                                                                                                                                    func (e *UnauthorizedException) Error() string

                                                                                                                                    func (*UnauthorizedException) ErrorCode

                                                                                                                                    func (e *UnauthorizedException) ErrorCode() string

                                                                                                                                    func (*UnauthorizedException) ErrorFault

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

                                                                                                                                    func (*UnauthorizedException) ErrorMessage

                                                                                                                                    func (e *UnauthorizedException) ErrorMessage() string

                                                                                                                                    type UserPoolConfig

                                                                                                                                    type UserPoolConfig struct {
                                                                                                                                    
                                                                                                                                    	// The AWS Region in which the user pool was created.
                                                                                                                                    	//
                                                                                                                                    	// This member is required.
                                                                                                                                    	AwsRegion *string
                                                                                                                                    
                                                                                                                                    	// The action that you want your GraphQL API to take when a request that uses
                                                                                                                                    	// Amazon Cognito user pool authentication doesn't match the Amazon Cognito user
                                                                                                                                    	// pool configuration.
                                                                                                                                    	//
                                                                                                                                    	// This member is required.
                                                                                                                                    	DefaultAction DefaultAction
                                                                                                                                    
                                                                                                                                    	// The user pool ID.
                                                                                                                                    	//
                                                                                                                                    	// This member is required.
                                                                                                                                    	UserPoolId *string
                                                                                                                                    
                                                                                                                                    	// A regular expression for validating the incoming Amazon Cognito user pool app
                                                                                                                                    	// client ID.
                                                                                                                                    	AppIdClientRegex *string
                                                                                                                                    }

                                                                                                                                      Describes an Amazon Cognito user pool configuration.