type AccessDeniedException struct {
	Message *string
}

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
}

type ApiCache struct {

	// Caching behavior.
	//
	//     * FULL_REQUEST_CACHING: All requests are fully cached.
	//
	//
	// * PER_RESOLVER_CACHING: Individual resovlers 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.
	//
	//     * 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
}

type ApiCacheStatus string

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

type ApiCacheType string

const (
	ApiCacheTypeT2_small   ApiCacheType = "T2_SMALL"
	ApiCacheTypeT2_medium  ApiCacheType = "T2_MEDIUM"
	ApiCacheTypeR4_large   ApiCacheType = "R4_LARGE"
	ApiCacheTypeR4_xlarge  ApiCacheType = "R4_XLARGE"
	ApiCacheTypeR4_2xlarge ApiCacheType = "R4_2XLARGE"
	ApiCacheTypeR4_4xlarge ApiCacheType = "R4_4XLARGE"
	ApiCacheTypeR4_8xlarge ApiCacheType = "R4_8XLARGE"
	ApiCacheTypeSmall      ApiCacheType = "SMALL"
	ApiCacheTypeMedium     ApiCacheType = "MEDIUM"
	ApiCacheTypeLarge      ApiCacheType = "LARGE"
	ApiCacheTypeXlarge     ApiCacheType = "XLARGE"
	ApiCacheTypeLarge_2x   ApiCacheType = "LARGE_2X"
	ApiCacheTypeLarge_4x   ApiCacheType = "LARGE_4X"
	ApiCacheTypeLarge_8x   ApiCacheType = "LARGE_8X"
	ApiCacheTypeLarge_12x  ApiCacheType = "LARGE_12X"
)

type ApiCachingBehavior string

const (
	ApiCachingBehaviorFull_request_caching ApiCachingBehavior = "FULL_REQUEST_CACHING"
	ApiCachingBehaviorPer_resolver_caching ApiCachingBehavior = "PER_RESOLVER_CACHING"
)

type ApiKey struct {

	// 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
}

type ApiKeyLimitExceededException struct {
	Message *string
}

type ApiKeyValidityOutOfBoundsException struct {
	Message *string
}

type ApiLimitExceededException struct {
	Message *string
}

type AuthenticationType string

const (
	AuthenticationTypeApi_key                   AuthenticationType = "API_KEY"
	AuthenticationTypeAws_iam                   AuthenticationType = "AWS_IAM"
	AuthenticationTypeAmazon_cognito_user_pools AuthenticationType = "AMAZON_COGNITO_USER_POOLS"
	AuthenticationTypeOpenid_connect            AuthenticationType = "OPENID_CONNECT"
)

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
}

type AuthorizationType string

const (
	AuthorizationTypeAws_iam AuthorizationType = "AWS_IAM"
)

type AwsIamConfig struct {

	// The signing region for AWS IAM authorization.
	SigningRegion *string

	// The signing service name for AWS IAM authorization.
	SigningServiceName *string
}

type BadRequestException struct {
	Message *string
}

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
}

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
}

type ConcurrentModificationException struct {
	Message *string
}

type ConflictDetectionType string

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

type ConflictHandlerType string

const (
	ConflictHandlerTypeOptimistic_concurrency ConflictHandlerType = "OPTIMISTIC_CONCURRENCY"
	ConflictHandlerTypeLambda                 ConflictHandlerType = "LAMBDA"
	ConflictHandlerTypeAutomerge              ConflictHandlerType = "AUTOMERGE"
	ConflictHandlerTypeNone                   ConflictHandlerType = "NONE"
)

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
}

type DataSourceType string

const (
	DataSourceTypeAws_lambda           DataSourceType = "AWS_LAMBDA"
	DataSourceTypeAmazon_dynamodb      DataSourceType = "AMAZON_DYNAMODB"
	DataSourceTypeAmazon_elasticsearch DataSourceType = "AMAZON_ELASTICSEARCH"
	DataSourceTypeNone                 DataSourceType = "NONE"
	DataSourceTypeHttp                 DataSourceType = "HTTP"
	DataSourceTypeRelational_database  DataSourceType = "RELATIONAL_DATABASE"
)

type DefaultAction string

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

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
}

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
}

type ElasticsearchDataSourceConfig struct {

	// The AWS Region.
	//
	// This member is required.
	AwsRegion *string

	// The endpoint.
	//
	// This member is required.
	Endpoint *string
}

type FieldLogLevel string

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

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
}

type GraphQLSchemaException struct {
	Message *string
}

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

	// A flag representing whether X-Ray tracing is enabled for this GraphqlApi.
	XrayEnabled *bool
}

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
}

type InternalFailureException struct {
	Message *string
}

type LambdaConflictHandlerConfig struct {

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

type LambdaDataSourceConfig struct {

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

type LimitExceededException struct {
	Message *string
}

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
}

type NotFoundException struct {
	Message *string
}

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
}

type OutputType string

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

type PipelineConfig struct {

	// A list of Function objects.
	Functions []*string
}

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
}

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
}

type RelationalDatabaseSourceType string

const (
	RelationalDatabaseSourceTypeRds_http_endpoint RelationalDatabaseSourceType = "RDS_HTTP_ENDPOINT"
)

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
}

type ResolverKind string

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

type SchemaStatus string

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

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
}

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
}

type TypeDefinitionFormat string

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

type UnauthorizedException struct {
	Message *string
}

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
}