types

package
v1.1.1 Latest Latest
Warning

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

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

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 added in v0.29.0 

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 added in v0.29.0 

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 added in v0.29.0 

func (ApiCachingBehavior) Values() []ApiCachingBehavior

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 (e *ApiKeyLimitExceededException) Error() string

func (*ApiKeyLimitExceededException) ErrorCode 

func (e *ApiKeyLimitExceededException) ErrorCode() string

func (*ApiKeyLimitExceededException) ErrorFault 

func (e *ApiKeyLimitExceededException) ErrorFault() smithy.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 (e *ApiKeyValidityOutOfBoundsException) Error() string

func (*ApiKeyValidityOutOfBoundsException) ErrorCode 

func (e *ApiKeyValidityOutOfBoundsException) ErrorCode() string

func (*ApiKeyValidityOutOfBoundsException) ErrorFault 

func (e *ApiKeyValidityOutOfBoundsException) ErrorFault() smithy.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 (e *ApiLimitExceededException) ErrorFault() smithy.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 added in v0.29.0 

func (AuthenticationType) Values() []AuthenticationType

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 added in v0.29.0 

func (AuthorizationType) Values() []AuthorizationType

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 (e *ConcurrentModificationException) Error() string

func (*ConcurrentModificationException) ErrorCode 

func (e *ConcurrentModificationException) ErrorCode() string

func (*ConcurrentModificationException) ErrorFault 

func (e *ConcurrentModificationException) ErrorFault() smithy.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 added in v0.29.0 

func (ConflictDetectionType) Values() []ConflictDetectionType

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 added in v0.29.0 

func (ConflictHandlerType) Values() []ConflictHandlerType

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 added in v0.29.0 

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 added in v0.29.0 

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 added in v0.29.0 

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 added in v0.29.0 

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 added in v0.29.0 

func (RelationalDatabaseSourceType) Values() []RelationalDatabaseSourceType

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 added in v0.29.0 

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 added in v0.29.0 

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 added in v0.29.0 

func (TypeDefinitionFormat) Values() []TypeDefinitionFormat

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.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.