Module aws_sdk_appsync::types

Data structures used by operation inputs/outputs.

Modules

• builders
  Builders
• error
  Error types that AWS AppSync can respond with.

Structs

• AdditionalAuthenticationProvider

  Describes an additional authentication provider.

• ApiAssociation

  Describes an ApiAssociation object.

• ApiCache

  The ApiCache object.

• ApiKey

  Describes an API key.

• AppSyncRuntime

  Describes a runtime used by an Amazon Web Services AppSync pipeline resolver or Amazon Web Services AppSync function. Specifies the name and version of the runtime to use. Note that if a runtime is specified, code must also be specified.

• AuthorizationConfig

  The authorization configuration in case the HTTP endpoint requires authorization.

• AwsIamConfig

  The Identity and Access Management (IAM) configuration.

• BadRequestDetail

  Provides further details for the reason behind the bad request. For reason type CODE_ERROR, the detail will contain a list of code errors.

• CachingConfig

  The caching configuration for a resolver that has caching activated.

• CodeError

  Describes an AppSync error.

• CodeErrorLocation

  Describes the location of the error in a code sample.

• CognitoUserPoolConfig

  Describes an Amazon Cognito user pool configuration.

• DataSource

  Describes a data source.

• DeltaSyncConfig

  Describes a Delta Sync configuration.

• DomainNameConfig

  Describes a configuration for a custom domain.

• DynamodbDataSourceConfig

  Describes an Amazon DynamoDB data source configuration.

• ElasticsearchDataSourceConfig

  Describes an OpenSearch data source configuration.

• ErrorDetail

  Contains the list of errors generated. When using JavaScript, this will apply to the request or response function evaluation.

• EvaluateCodeErrorDetail

  Contains the list of errors from a code evaluation response.

• EventBridgeDataSourceConfig

  Describes an Amazon EventBridge bus data source configuration.

• FunctionConfiguration

  A function is a reusable entity. You can use multiple functions to compose the resolver logic.

• GraphqlApi

  Describes a GraphQL API.

• HttpDataSourceConfig

  Describes an HTTP data source configuration.

• LambdaAuthorizerConfig

  A LambdaAuthorizerConfig specifies how to authorize AppSync API access when using the AWS_LAMBDA authorizer mode. Be aware that an AppSync API can have only one Lambda authorizer configured at a time.

• LambdaConflictHandlerConfig

  The LambdaConflictHandlerConfig object when configuring LAMBDA as the Conflict Handler.

• LambdaDataSourceConfig

  Describes an Lambda data source configuration.

• LogConfig

  The Amazon CloudWatch Logs configuration.

• OpenIdConnectConfig

  Describes an OpenID Connect (OIDC) configuration.

• OpenSearchServiceDataSourceConfig

  Describes an OpenSearch data source configuration.

• PipelineConfig

  The pipeline configuration for a resolver of kind PIPELINE.

• RdsHttpEndpointConfig

  The Amazon Relational Database Service (Amazon RDS) HTTP endpoint configuration.

• RelationalDatabaseDataSourceConfig

  Describes a relational database data source configuration.

• Resolver

  Describes a resolver.

• SourceApiAssociation

  Describes the configuration of a source API. A source API is a GraphQL API that is linked to a merged API. There can be multiple source APIs attached to each merged API. When linked to a merged API, the source API's schema, data sources, and resolvers will be combined with other linked source API data to form a new, singular API.

• SourceApiAssociationConfig

  Describes properties used to specify configurations related to a source API.

• SourceApiAssociationSummary

  Describes the ARNs and IDs of associations, Merged APIs, and source APIs.

• SyncConfig

  Describes a Sync configuration for a resolver.

• Type

  Describes a type.

• UserPoolConfig

  Describes an Amazon Cognito user pool configuration.

Enums

• ApiCacheStatus
  When writing a match expression against ApiCacheStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ApiCacheType
  When writing a match expression against ApiCacheType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ApiCachingBehavior
  When writing a match expression against ApiCachingBehavior, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• AssociationStatus
  When writing a match expression against AssociationStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• AuthenticationType
  When writing a match expression against AuthenticationType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• AuthorizationType
  When writing a match expression against AuthorizationType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• BadRequestReason
  When writing a match expression against BadRequestReason, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ConflictDetectionType
  When writing a match expression against ConflictDetectionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ConflictHandlerType
  When writing a match expression against ConflictHandlerType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• DataSourceType
  When writing a match expression against DataSourceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• DefaultAction
  When writing a match expression against DefaultAction, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• FieldLogLevel
  When writing a match expression against FieldLogLevel, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• GraphQlApiType
  When writing a match expression against GraphQlApiType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• GraphQlApiVisibility
  When writing a match expression against GraphQlApiVisibility, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• MergeType
  When writing a match expression against MergeType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• OutputType
  When writing a match expression against OutputType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• Ownership
  When writing a match expression against Ownership, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• RelationalDatabaseSourceType
  When writing a match expression against RelationalDatabaseSourceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ResolverKind
  When writing a match expression against ResolverKind, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• RuntimeName
  When writing a match expression against RuntimeName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• SchemaStatus
  When writing a match expression against SchemaStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• SourceApiAssociationStatus
  When writing a match expression against SourceApiAssociationStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• TypeDefinitionFormat
  When writing a match expression against TypeDefinitionFormat, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.