//// Generated from com.amazonaws.dynamodb#DynamoDB_20120810 (awsJson1_0).
//// DO NOT EDIT. Re-generate via the codegen subproject.

import aws/credentials
import aws/endpoints
import aws/internal/client/runtime
import aws/internal/codec/json_float
import aws/internal/codec/json_timestamp
import aws/internal/credentials_cache
import aws/internal/http_send
import aws/pagination
import aws/region
import aws/waiter
import gleam/bit_array
import gleam/dict
import gleam/dynamic/decode
import gleam/int
import gleam/json
import gleam/list
import gleam/option
import gleam/result

pub opaque type Client {
  Client(config: runtime.ClientConfig, cache: credentials_cache.Cache)
}

/// Smithy endpoint rule set for this service, lifted verbatim
/// from the source model. Parsed once in `new` and attached to
/// every Client via `runtime.with_endpoint_rule_set`.
const endpoint_rule_set_json: String = "{\"parameters\":{\"AccountId\":{\"builtIn\":\"AWS::Auth::AccountId\",\"documentation\":\"The AWS AccountId used for the request.\",\"required\":false,\"type\":\"string\"},\"AccountIdEndpointMode\":{\"builtIn\":\"AWS::Auth::AccountIdEndpointMode\",\"documentation\":\"The AccountId Endpoint Mode.\",\"required\":false,\"type\":\"string\"},\"Endpoint\":{\"builtIn\":\"SDK::Endpoint\",\"documentation\":\"Override the endpoint used to send this request\",\"required\":false,\"type\":\"string\"},\"Region\":{\"builtIn\":\"AWS::Region\",\"documentation\":\"The AWS region used to dispatch the request.\",\"required\":false,\"type\":\"string\"},\"ResourceArn\":{\"documentation\":\"ResourceArn containing arn of resource\",\"required\":false,\"type\":\"string\"},\"ResourceArnList\":{\"documentation\":\"ResourceArnList containing list of resource arns\",\"required\":false,\"type\":\"stringArray\"},\"UseDualStack\":{\"builtIn\":\"AWS::UseDualStack\",\"default\":false,\"documentation\":\"When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.\",\"required\":true,\"type\":\"boolean\"},\"UseFIPS\":{\"builtIn\":\"AWS::UseFIPS\",\"default\":false,\"documentation\":\"When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.\",\"required\":true,\"type\":\"boolean\"}},\"rules\":[{\"conditions\":[{\"argv\":[{\"ref\":\"Endpoint\"}],\"fn\":\"isSet\"},{\"argv\":[{\"ref\":\"Region\"}],\"fn\":\"isSet\"},{\"argv\":[{\"ref\":\"Region\"}],\"assign\":\"PartitionResult\",\"fn\":\"aws.partition\"}],\"rules\":[{\"conditions\":[{\"argv\":[{\"ref\":\"UseFIPS\"},true],\"fn\":\"booleanEquals\"}],\"error\":\"Invalid Configuration: FIPS and custom endpoint are not supported\",\"type\":\"error\"},{\"conditions\":[{\"argv\":[{\"ref\":\"UseDualStack\"},true],\"fn\":\"booleanEquals\"}],\"error\":\"Invalid Configuration: Dualstack and custom endpoint are not supported\",\"type\":\"error\"},{\"conditions\":[{\"argv\":[{\"ref\":\"Endpoint\"},\"https://dynamodb.{Region}.{PartitionResult#dualStackDnsSuffix}\"],\"fn\":\"stringEquals\"}],\"error\":\"Endpoint override is not supported for dual-stack endpoints. Please enable dual-stack functionality by enabling the configuration. For more details, see: https://docs.aws.amazon.com/sdkref/latest/guide/feature-endpoints.html\",\"type\":\"error\"},{\"conditions\":[],\"endpoint\":{\"headers\":{},\"properties\":{},\"url\":\"{Endpoint}\"},\"type\":\"endpoint\"}],\"type\":\"tree\"},{\"conditions\":[{\"argv\":[{\"ref\":\"Endpoint\"}],\"fn\":\"isSet\"}],\"rules\":[{\"conditions\":[{\"argv\":[{\"ref\":\"UseFIPS\"},true],\"fn\":\"booleanEquals\"}],\"error\":\"Invalid Configuration: FIPS and custom endpoint are not supported\",\"type\":\"error\"},{\"conditions\":[{\"argv\":[{\"ref\":\"UseDualStack\"},true],\"fn\":\"booleanEquals\"}],\"error\":\"Invalid Configuration: Dualstack and custom endpoint are not supported\",\"type\":\"error\"},{\"conditions\":[],\"endpoint\":{\"headers\":{},\"properties\":{},\"url\":\"{Endpoint}\"},\"type\":\"endpoint\"}],\"type\":\"tree\"},{\"conditions\":[{\"argv\":[{\"ref\":\"Region\"}],\"fn\":\"isSet\"}],\"rules\":[{\"conditions\":[{\"argv\":[{\"ref\":\"Region\"}],\"assign\":\"PartitionResult\",\"fn\":\"aws.partition\"}],\"rules\":[{\"conditions\":[{\"argv\":[{\"ref\":\"Region\"},\"local\"],\"fn\":\"stringEquals\"}],\"rules\":[{\"conditions\":[{\"argv\":[{\"ref\":\"UseFIPS\"},true],\"fn\":\"booleanEquals\"}],\"error\":\"Invalid Configuration: FIPS and local endpoint are not supported\",\"type\":\"error\"},{\"conditions\":[{\"argv\":[{\"ref\":\"UseDualStack\"},true],\"fn\":\"booleanEquals\"}],\"error\":\"Invalid Configuration: Dualstack and local endpoint are not supported\",\"type\":\"error\"},{\"conditions\":[],\"endpoint\":{\"headers\":{},\"properties\":{\"authSchemes\":[{\"name\":\"sigv4\",\"signingName\":\"dynamodb\",\"signingRegion\":\"us-east-1\"}]},\"url\":\"http://localhost:8000\"},\"type\":\"endpoint\"}],\"type\":\"tree\"},{\"conditions\":[{\"argv\":[{\"ref\":\"UseFIPS\"},true],\"fn\":\"booleanEquals\"},{\"argv\":[{\"ref\":\"UseDualStack\"},true],\"fn\":\"booleanEquals\"}],\"rules\":[{\"conditions\":[{\"argv\":[{\"argv\":[{\"ref\":\"PartitionResult\"},\"supportsFIPS\"],\"fn\":\"getAttr\"},true],\"fn\":\"booleanEquals\"},{\"argv\":[{\"argv\":[{\"ref\":\"PartitionResult\"},\"supportsDualStack\"],\"fn\":\"getAttr\"},true],\"fn\":\"booleanEquals\"}],\"rules\":[{\"conditions\":[{\"argv\":[{\"ref\":\"AccountIdEndpointMode\"}],\"fn\":\"isSet\"},{\"argv\":[{\"ref\":\"AccountIdEndpointMode\"},\"required\"],\"fn\":\"stringEquals\"}],\"rules\":[{\"conditions\":[],\"error\":\"Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported\",\"type\":\"error\"}],\"type\":\"tree\"},{\"conditions\":[],\"endpoint\":{\"headers\":{},\"properties\":{},\"url\":\"https://dynamodb-fips.{Region}.{PartitionResult#dualStackDnsSuffix}\"},\"type\":\"endpoint\"}],\"type\":\"tree\"},{\"conditions\":[],\"error\":\"FIPS and DualStack are enabled, but this partition does not support one or both\",\"type\":\"error\"}],\"type\":\"tree\"},{\"conditions\":[{\"argv\":[{\"ref\":\"UseFIPS\"},true],\"fn\":\"booleanEquals\"}],\"rules\":[{\"conditions\":[{\"argv\":[{\"argv\":[{\"ref\":\"PartitionResult\"},\"supportsFIPS\"],\"fn\":\"getAttr\"},true],\"fn\":\"booleanEquals\"}],\"rules\":[{\"conditions\":[{\"argv\":[{\"argv\":[{\"ref\":\"PartitionResult\"},\"name\"],\"fn\":\"getAttr\"},\"aws-us-gov\"],\"fn\":\"stringEquals\"}],\"rules\":[{\"conditions\":[{\"argv\":[{\"ref\":\"AccountIdEndpointMode\"}],\"fn\":\"isSet\"},{\"argv\":[{\"ref\":\"AccountIdEndpointMode\"},\"required\"],\"fn\":\"stringEquals\"}],\"rules\":[{\"conditions\":[],\"error\":\"Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported\",\"type\":\"error\"}],\"type\":\"tree\"},{\"conditions\":[],\"endpoint\":{\"headers\":{},\"properties\":{},\"url\":\"https://dynamodb.{Region}.{PartitionResult#dnsSuffix}\"},\"type\":\"endpoint\"}],\"type\":\"tree\"},{\"conditions\":[{\"argv\":[{\"ref\":\"AccountIdEndpointMode\"}],\"fn\":\"isSet\"},{\"argv\":[{\"ref\":\"AccountIdEndpointMode\"},\"required\"],\"fn\":\"stringEquals\"}],\"rules\":[{\"conditions\":[],\"error\":\"Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported\",\"type\":\"error\"}],\"type\":\"tree\"},{\"conditions\":[],\"endpoint\":{\"headers\":{},\"properties\":{},\"url\":\"https://dynamodb-fips.{Region}.{PartitionResult#dnsSuffix}\"},\"type\":\"endpoint\"}],\"type\":\"tree\"},{\"conditions\":[],\"error\":\"FIPS is enabled but this partition does not support FIPS\",\"type\":\"error\"}],\"type\":\"tree\"},{\"conditions\":[{\"argv\":[{\"ref\":\"UseDualStack\"},true],\"fn\":\"booleanEquals\"}],\"rules\":[{\"conditions\":[{\"argv\":[{\"argv\":[{\"ref\":\"PartitionResult\"},\"supportsDualStack\"],\"fn\":\"getAttr\"},true],\"fn\":\"booleanEquals\"}],\"rules\":[{\"conditions\":[{\"argv\":[{\"ref\":\"AccountIdEndpointMode\"}],\"fn\":\"isSet\"},{\"argv\":[{\"argv\":[{\"ref\":\"AccountIdEndpointMode\"},\"disabled\"],\"fn\":\"stringEquals\"}],\"fn\":\"not\"},{\"argv\":[{\"argv\":[{\"ref\":\"PartitionResult\"},\"name\"],\"fn\":\"getAttr\"},\"aws\"],\"fn\":\"stringEquals\"},{\"argv\":[{\"argv\":[{\"ref\":\"UseFIPS\"},true],\"fn\":\"booleanEquals\"}],\"fn\":\"not\"},{\"argv\":[{\"ref\":\"ResourceArn\"}],\"fn\":\"isSet\"},{\"argv\":[{\"ref\":\"ResourceArn\"}],\"assign\":\"ParsedArn\",\"fn\":\"aws.parseArn\"},{\"argv\":[{\"argv\":[{\"ref\":\"ParsedArn\"},\"service\"],\"fn\":\"getAttr\"},\"dynamodb\"],\"fn\":\"stringEquals\"},{\"argv\":[{\"argv\":[{\"ref\":\"ParsedArn\"},\"region\"],\"fn\":\"getAttr\"},false],\"fn\":\"isValidHostLabel\"},{\"argv\":[{\"argv\":[{\"ref\":\"ParsedArn\"},\"region\"],\"fn\":\"getAttr\"},\"{Region}\"],\"fn\":\"stringEquals\"},{\"argv\":[{\"argv\":[{\"ref\":\"ParsedArn\"},\"accountId\"],\"fn\":\"getAttr\"},false],\"fn\":\"isValidHostLabel\"}],\"endpoint\":{\"headers\":{},\"properties\":{\"metricValues\":[\"O\"]},\"url\":\"https://{ParsedArn#accountId}.ddb.{Region}.{PartitionResult#dualStackDnsSuffix}\"},\"type\":\"endpoint\"},{\"conditions\":[{\"argv\":[{\"ref\":\"AccountIdEndpointMode\"}],\"fn\":\"isSet\"},{\"argv\":[{\"argv\":[{\"ref\":\"AccountIdEndpointMode\"},\"disabled\"],\"fn\":\"stringEquals\"}],\"fn\":\"not\"},{\"argv\":[{\"argv\":[{\"ref\":\"PartitionResult\"},\"name\"],\"fn\":\"getAttr\"},\"aws\"],\"fn\":\"stringEquals\"},{\"argv\":[{\"argv\":[{\"ref\":\"UseFIPS\"},true],\"fn\":\"booleanEquals\"}],\"fn\":\"not\"},{\"argv\":[{\"ref\":\"ResourceArnList\"}],\"fn\":\"isSet\"},{\"argv\":[{\"ref\":\"ResourceArnList\"},\"[0]\"],\"assign\":\"FirstArn\",\"fn\":\"getAttr\"},{\"argv\":[{\"ref\":\"FirstArn\"}],\"assign\":\"ParsedArn\",\"fn\":\"aws.parseArn\"},{\"argv\":[{\"argv\":[{\"ref\":\"ParsedArn\"},\"service\"],\"fn\":\"getAttr\"},\"dynamodb\"],\"fn\":\"stringEquals\"},{\"argv\":[{\"argv\":[{\"ref\":\"ParsedArn\"},\"region\"],\"fn\":\"getAttr\"},false],\"fn\":\"isValidHostLabel\"},{\"argv\":[{\"argv\":[{\"ref\":\"ParsedArn\"},\"region\"],\"fn\":\"getAttr\"},\"{Region}\"],\"fn\":\"stringEquals\"},{\"argv\":[{\"argv\":[{\"ref\":\"ParsedArn\"},\"accountId\"],\"fn\":\"getAttr\"},false],\"fn\":\"isValidHostLabel\"}],\"endpoint\":{\"headers\":{},\"properties\":{\"metricValues\":[\"O\"]},\"url\":\"https://{ParsedArn#accountId}.ddb.{Region}.{PartitionResult#dualStackDnsSuffix}\"},\"type\":\"endpoint\"},{\"conditions\":[{\"argv\":[{\"ref\":\"AccountIdEndpointMode\"}],\"fn\":\"isSet\"},{\"argv\":[{\"argv\":[{\"ref\":\"AccountIdEndpointMode\"},\"disabled\"],\"fn\":\"stringEquals\"}],\"fn\":\"not\"},{\"argv\":[{\"argv\":[{\"ref\":\"PartitionResult\"},\"name\"],\"fn\":\"getAttr\"},\"aws\"],\"fn\":\"stringEquals\"},{\"argv\":[{\"argv\":[{\"ref\":\"UseFIPS\"},true],\"fn\":\"booleanEquals\"}],\"fn\":\"not\"},{\"argv\":[{\"ref\":\"AccountId\"}],\"fn\":\"isSet\"}],\"rules\":[{\"conditions\":[{\"argv\":[{\"ref\":\"AccountId\"},false],\"fn\":\"isValidHostLabel\"}],\"rules\":[{\"conditions\":[],\"endpoint\":{\"headers\":{},\"properties\":{\"metricValues\":[\"O\"]},\"url\":\"https://{AccountId}.ddb.{Region}.{PartitionResult#dualStackDnsSuffix}\"},\"type\":\"endpoint\"}],\"type\":\"tree\"},{\"conditions\":[],\"error\":\"Credentials-sourced account ID parameter is invalid\",\"type\":\"error\"}],\"type\":\"tree\"},{\"conditions\":[{\"argv\":[{\"ref\":\"AccountIdEndpointMode\"}],\"fn\":\"isSet\"},{\"argv\":[{\"ref\":\"AccountIdEndpointMode\"},\"required\"],\"fn\":\"stringEquals\"}],\"rules\":[{\"conditions\":[{\"argv\":[{\"argv\":[{\"ref\":\"UseFIPS\"},true],\"fn\":\"booleanEquals\"}],\"fn\":\"not\"}],\"rules\":[{\"conditions\":[{\"argv\":[{\"argv\":[{\"ref\":\"PartitionResult\"},\"name\"],\"fn\":\"getAttr\"},\"aws\"],\"fn\":\"stringEquals\"}],\"rules\":[{\"conditions\":[],\"error\":\"AccountIdEndpointMode is required but no AccountID was provided or able to be loaded\",\"type\":\"error\"}],\"type\":\"tree\"},{\"conditions\":[],\"error\":\"Invalid Configuration: AccountIdEndpointMode is required but account endpoints are not supported in this partition\",\"type\":\"error\"}],\"type\":\"tree\"},{\"conditions\":[],\"error\":\"Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported\",\"type\":\"error\"}],\"type\":\"tree\"},{\"conditions\":[],\"endpoint\":{\"headers\":{},\"properties\":{},\"url\":\"https://dynamodb.{Region}.{PartitionResult#dualStackDnsSuffix}\"},\"type\":\"endpoint\"}],\"type\":\"tree\"},{\"conditions\":[],\"error\":\"DualStack is enabled but this partition does not support DualStack\",\"type\":\"error\"}],\"type\":\"tree\"},{\"conditions\":[{\"argv\":[{\"ref\":\"AccountIdEndpointMode\"}],\"fn\":\"isSet\"},{\"argv\":[{\"argv\":[{\"ref\":\"AccountIdEndpointMode\"},\"disabled\"],\"fn\":\"stringEquals\"}],\"fn\":\"not\"},{\"argv\":[{\"argv\":[{\"ref\":\"PartitionResult\"},\"name\"],\"fn\":\"getAttr\"},\"aws\"],\"fn\":\"stringEquals\"},{\"argv\":[{\"argv\":[{\"ref\":\"UseFIPS\"},true],\"fn\":\"booleanEquals\"}],\"fn\":\"not\"},{\"argv\":[{\"ref\":\"ResourceArn\"}],\"fn\":\"isSet\"},{\"argv\":[{\"ref\":\"ResourceArn\"}],\"assign\":\"ParsedArn\",\"fn\":\"aws.parseArn\"},{\"argv\":[{\"argv\":[{\"ref\":\"ParsedArn\"},\"service\"],\"fn\":\"getAttr\"},\"dynamodb\"],\"fn\":\"stringEquals\"},{\"argv\":[{\"argv\":[{\"ref\":\"ParsedArn\"},\"region\"],\"fn\":\"getAttr\"},false],\"fn\":\"isValidHostLabel\"},{\"argv\":[{\"argv\":[{\"ref\":\"ParsedArn\"},\"region\"],\"fn\":\"getAttr\"},\"{Region}\"],\"fn\":\"stringEquals\"},{\"argv\":[{\"argv\":[{\"ref\":\"ParsedArn\"},\"accountId\"],\"fn\":\"getAttr\"},false],\"fn\":\"isValidHostLabel\"}],\"endpoint\":{\"headers\":{},\"properties\":{\"metricValues\":[\"O\"]},\"url\":\"https://{ParsedArn#accountId}.ddb.{Region}.{PartitionResult#dnsSuffix}\"},\"type\":\"endpoint\"},{\"conditions\":[{\"argv\":[{\"ref\":\"AccountIdEndpointMode\"}],\"fn\":\"isSet\"},{\"argv\":[{\"argv\":[{\"ref\":\"AccountIdEndpointMode\"},\"disabled\"],\"fn\":\"stringEquals\"}],\"fn\":\"not\"},{\"argv\":[{\"argv\":[{\"ref\":\"PartitionResult\"},\"name\"],\"fn\":\"getAttr\"},\"aws\"],\"fn\":\"stringEquals\"},{\"argv\":[{\"argv\":[{\"ref\":\"UseFIPS\"},true],\"fn\":\"booleanEquals\"}],\"fn\":\"not\"},{\"argv\":[{\"ref\":\"ResourceArnList\"}],\"fn\":\"isSet\"},{\"argv\":[{\"ref\":\"ResourceArnList\"},\"[0]\"],\"assign\":\"FirstArn\",\"fn\":\"getAttr\"},{\"argv\":[{\"ref\":\"FirstArn\"}],\"assign\":\"ParsedArn\",\"fn\":\"aws.parseArn\"},{\"argv\":[{\"argv\":[{\"ref\":\"ParsedArn\"},\"service\"],\"fn\":\"getAttr\"},\"dynamodb\"],\"fn\":\"stringEquals\"},{\"argv\":[{\"argv\":[{\"ref\":\"ParsedArn\"},\"region\"],\"fn\":\"getAttr\"},false],\"fn\":\"isValidHostLabel\"},{\"argv\":[{\"argv\":[{\"ref\":\"ParsedArn\"},\"region\"],\"fn\":\"getAttr\"},\"{Region}\"],\"fn\":\"stringEquals\"},{\"argv\":[{\"argv\":[{\"ref\":\"ParsedArn\"},\"accountId\"],\"fn\":\"getAttr\"},false],\"fn\":\"isValidHostLabel\"}],\"endpoint\":{\"headers\":{},\"properties\":{\"metricValues\":[\"O\"]},\"url\":\"https://{ParsedArn#accountId}.ddb.{Region}.{PartitionResult#dnsSuffix}\"},\"type\":\"endpoint\"},{\"conditions\":[{\"argv\":[{\"ref\":\"AccountIdEndpointMode\"}],\"fn\":\"isSet\"},{\"argv\":[{\"argv\":[{\"ref\":\"AccountIdEndpointMode\"},\"disabled\"],\"fn\":\"stringEquals\"}],\"fn\":\"not\"},{\"argv\":[{\"argv\":[{\"ref\":\"PartitionResult\"},\"name\"],\"fn\":\"getAttr\"},\"aws\"],\"fn\":\"stringEquals\"},{\"argv\":[{\"argv\":[{\"ref\":\"UseFIPS\"},true],\"fn\":\"booleanEquals\"}],\"fn\":\"not\"},{\"argv\":[{\"ref\":\"AccountId\"}],\"fn\":\"isSet\"}],\"rules\":[{\"conditions\":[{\"argv\":[{\"ref\":\"AccountId\"},false],\"fn\":\"isValidHostLabel\"}],\"rules\":[{\"conditions\":[],\"endpoint\":{\"headers\":{},\"properties\":{\"metricValues\":[\"O\"]},\"url\":\"https://{AccountId}.ddb.{Region}.{PartitionResult#dnsSuffix}\"},\"type\":\"endpoint\"}],\"type\":\"tree\"},{\"conditions\":[],\"error\":\"Credentials-sourced account ID parameter is invalid\",\"type\":\"error\"}],\"type\":\"tree\"},{\"conditions\":[{\"argv\":[{\"ref\":\"AccountIdEndpointMode\"}],\"fn\":\"isSet\"},{\"argv\":[{\"ref\":\"AccountIdEndpointMode\"},\"required\"],\"fn\":\"stringEquals\"}],\"rules\":[{\"conditions\":[{\"argv\":[{\"argv\":[{\"ref\":\"UseFIPS\"},true],\"fn\":\"booleanEquals\"}],\"fn\":\"not\"}],\"rules\":[{\"conditions\":[{\"argv\":[{\"argv\":[{\"ref\":\"PartitionResult\"},\"name\"],\"fn\":\"getAttr\"},\"aws\"],\"fn\":\"stringEquals\"}],\"rules\":[{\"conditions\":[],\"error\":\"AccountIdEndpointMode is required but no AccountID was provided or able to be loaded\",\"type\":\"error\"}],\"type\":\"tree\"},{\"conditions\":[],\"error\":\"Invalid Configuration: AccountIdEndpointMode is required but account endpoints are not supported in this partition\",\"type\":\"error\"}],\"type\":\"tree\"},{\"conditions\":[],\"error\":\"Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported\",\"type\":\"error\"}],\"type\":\"tree\"},{\"conditions\":[],\"endpoint\":{\"headers\":{},\"properties\":{},\"url\":\"https://dynamodb.{Region}.{PartitionResult#dnsSuffix}\"},\"type\":\"endpoint\"}],\"type\":\"tree\"}],\"type\":\"tree\"},{\"conditions\":[],\"error\":\"Invalid Configuration: Missing Region\",\"type\":\"error\"}],\"version\":\"1.0\"}"

/// Build a Client for an AWS region. Credentials resolve through
/// the default chain (env → web-identity → SSO → profile → process
/// → ECS → IMDS); use `with_credentials_provider` to override.
pub fn new(region region: String) -> Client {
  let config = runtime.default_config(region, "dynamodb", "dynamodb")
  let assert Ok(cache) = credentials_cache.start_default(config.provider)
  let config =
    runtime.with_credentials_provider(
      config,
      credentials_cache.as_provider(cache),
    )
  let assert Ok(rule_set) = endpoints.parse_rule_set(endpoint_rule_set_json)
  let config = runtime.with_endpoint_rule_set(config, rule_set)
  Client(config: config, cache: cache)
}

/// Build a Client by resolving the region from the standard AWS
/// sources (`AWS_REGION`, `AWS_DEFAULT_REGION`, `~/.aws/config`).
/// Returns `Error(_)` when no source supplies a region — typical in
/// Lambda/ECS/EC2 where exactly one of these is always set.
pub fn new_with_auto_region() -> Result(Client, region.ResolveError) {
  use resolved <- result.try(region.resolve(profile: "default"))
  Ok(new(region: resolved))
}

/// Override the credentials provider — use for non-default
/// profiles, in-process static credentials, or a custom chain.
/// The supplied provider is wrapped in a fresh per-Client
/// credentials cache so callers don't lose refresh/coalesce
/// behaviour by overriding the default chain. The previously
/// running cache actor is stopped — call this on a Client value
/// you intend to keep, not on one that's about to be discarded.
pub fn with_credentials_provider(
  client: Client,
  provider: credentials.Provider,
) -> Client {
  let _ = credentials_cache.shutdown(client.cache)
  let assert Ok(cache) = credentials_cache.start_default(provider)
  Client(
    config: runtime.with_credentials_provider(
      client.config,
      credentials_cache.as_provider(cache),
    ),
    cache: cache,
  )
}

/// Override the endpoint URL (LocalStack, FIPS endpoints, custom DNS).
pub fn with_endpoint_url(client: Client, url: String) -> Client {
  Client(
    config: runtime.with_endpoint_url(client.config, url),
    cache: client.cache,
  )
}

/// Swap the HTTP transport — useful for canned-response test doubles.
pub fn with_http_send(client: Client, send: http_send.Send) -> Client {
  Client(
    config: runtime.with_http_send(client.config, send),
    cache: client.cache,
  )
}

/// Swap the streaming HTTP transport. Same role as `with_http_send`
/// but targets the `@streaming` output path (`runtime.invoke_streaming`).
/// Use for canned-response test doubles on streaming ops, or to plug
/// in a custom chunked transport (proxy, gRPC tunnel, instrumented
/// sender) without disturbing the buffered path.
pub fn with_streaming_http_send(
  client: Client,
  send: http_send.StreamingSend,
) -> Client {
  Client(
    config: runtime.with_streaming_http_send(client.config, send),
    cache: client.cache,
  )
}

/// Switch the streaming sender to the HTTP/2 variant. httpc adds
/// `{http_version, "HTTP/2"}` to its option list; servers that
/// don't speak HTTP/2 negotiate down to HTTP/1.1 via ALPN, so
/// calls keep working even when the peer doesn't support it.
/// Buffered requests (`with_http_send`) are unaffected — HTTP/2
/// is for high-throughput streaming endpoints (S3 multipart,
/// Bedrock streaming, Transcribe).
pub fn with_http2(client: Client) -> Client {
  Client(config: runtime.with_http2(client.config), cache: client.cache)
}

/// Opt the Client into SigV4a (asymmetric ECDSA P-256) signing
/// for every request. `region_set` becomes the `X-Amz-Region-Set`
/// header — single-region callers pass `["us-east-1"]`,
/// multi-region callers pass the full list. Required for S3
/// Multi-Region Access Points and any other endpoint that demands
/// AWS4-ECDSA-P256-SHA256 signatures.
pub fn with_sigv4a_region_set(
  client: Client,
  region_set: List(String),
) -> Client {
  Client(
    config: runtime.with_sigv4a_region_set(client.config, region_set),
    cache: client.cache,
  )
}

/// Override SigV4a's `normalize_path` (RFC 3986 dot-segment removal).
/// No-op when `with_sigv4a_region_set` has not been called yet — the
/// knob lives on the per-Client SigV4a state, not on the underlying
/// transport. S3 callers need `False` so object keys with `.` / `..`
/// survive the canonical-request step.
pub fn with_sigv4a_path_normalization(
  client: Client,
  normalize: Bool,
) -> Client {
  Client(
    config: runtime.with_sigv4a_path_normalization(client.config, normalize),
    cache: client.cache,
  )
}

/// Override the retry attempt budget on the underlying ClientConfig.
/// The common case for retry tuning — pass `1` to disable retries
/// entirely (single attempt per request), `5` for long-running batch
/// workloads. Preserves the other retry knobs (delays, sleep, rng,
/// rate-limiter); use `runtime.with_retry_strategy` for full control.
pub fn with_max_attempts(client: Client, n: Int) -> Client {
  Client(
    config: runtime.with_max_attempts(client.config, n),
    cache: client.cache,
  )
}

/// The AWS AccountId used for the request.
/// Wire form: `runtime.with_endpoint_param(config, "AccountId", ...)`.
pub fn with_account_id(client: Client, value: String) -> Client {
  Client(
    config: runtime.with_endpoint_param(
      client.config,
      "AccountId",
      endpoints.StringVal(value),
    ),
    cache: client.cache,
  )
}

/// The AccountId Endpoint Mode.
/// Wire form: `runtime.with_endpoint_param(config, "AccountIdEndpointMode", ...)`.
pub fn with_account_id_endpoint_mode(client: Client, value: String) -> Client {
  Client(
    config: runtime.with_endpoint_param(
      client.config,
      "AccountIdEndpointMode",
      endpoints.StringVal(value),
    ),
    cache: client.cache,
  )
}

/// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
/// Wire form: `runtime.with_endpoint_param(config, "UseDualStack", ...)`.
pub fn with_use_dual_stack(client: Client, value: Bool) -> Client {
  Client(
    config: runtime.with_endpoint_param(
      client.config,
      "UseDualStack",
      endpoints.BoolVal(value),
    ),
    cache: client.cache,
  )
}

/// When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.
/// Wire form: `runtime.with_endpoint_param(config, "UseFIPS", ...)`.
pub fn with_use_fips(client: Client, value: Bool) -> Client {
  Client(
    config: runtime.with_endpoint_param(
      client.config,
      "UseFIPS",
      endpoints.BoolVal(value),
    ),
    cache: client.cache,
  )
}

/// Read the underlying `runtime.ClientConfig` out of an existing
/// `Client`. Use this when you want to dispatch a request through
/// `runtime.invoke` / `runtime.invoke_streaming` directly — e.g. to
/// build a service-specific streaming wrapper around a `@streaming`
/// output operation that the per-op codegen hasn't surfaced yet.
/// The returned config is a value (Gleam records are immutable);
/// callers cannot mutate the Client through it.
pub fn config(client: Client) -> runtime.ClientConfig {
  client.config
}

/// Release the per-Client credentials cache actor. Call this when a
/// Client value is no longer needed — long-running processes that
/// build many Clients (tests, scripts, multi-tenant servers) will
/// otherwise accumulate one BEAM process per `new` call. Fire-and-
/// forget; safe to call multiple times. For tests or graceful
/// shutdown that must observe the actor's exit, use `shutdown_sync`.
pub fn shutdown(client: Client) -> Nil {
  credentials_cache.shutdown(client.cache)
}

/// Like `shutdown` but blocks until the credentials cache actor has
/// actually exited (or `timeout_ms` elapses). `Ok(Nil)` indicates a
/// clean exit; `Error(Nil)` indicates the timeout fired and the
/// actor was still alive when the caller gave up.
pub fn shutdown_sync(
  client: Client,
  timeout_ms timeout_ms: Int,
) -> Result(Nil, Nil) {
  credentials_cache.shutdown_sync(client.cache, timeout_ms)
}

pub type BatchExecuteStatementInput {
  BatchExecuteStatementInput(
    return_consumed_capacity: option.Option(ReturnConsumedCapacity),
    statements: option.Option(List(BatchStatementRequest)),
  )
}

pub fn batch_execute_statement_input_default() -> BatchExecuteStatementInput {
  BatchExecuteStatementInput(
    return_consumed_capacity: option.None,
    statements: option.None,
  )
}

pub fn encode_batch_execute_statement_input_struct(
  input: BatchExecuteStatementInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.return_consumed_capacity {
    option.Some(v) -> [
      #("ReturnConsumedCapacity", encode_return_consumed_capacity_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.statements {
    option.Some(v) -> [
      #(
        "Statements",
        fn(xs) { json.array(xs, encode_batch_statement_request_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_batch_execute_statement_input_struct_top(
  input: BatchExecuteStatementInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.return_consumed_capacity {
    option.Some(v) -> [
      #("ReturnConsumedCapacity", encode_return_consumed_capacity_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.statements {
    option.Some(v) -> [
      #(
        "Statements",
        fn(xs) { json.array(xs, encode_batch_statement_request_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_batch_execute_statement_input_struct() -> decode.Decoder(
  BatchExecuteStatementInput,
) {
  use <- decode.recursive
  use return_consumed_capacity <- decode.optional_field(
    "ReturnConsumedCapacity",
    option.None,
    decode.optional(decode_return_consumed_capacity_enum()),
  )
  use statements <- decode.optional_field(
    "Statements",
    option.None,
    decode.optional(decode.list(decode_batch_statement_request_struct())),
  )
  decode.success(BatchExecuteStatementInput(
    return_consumed_capacity: return_consumed_capacity,
    statements: statements,
  ))
}

pub type ReturnConsumedCapacity {
  ReturnConsumedCapacityIndexes
  ReturnConsumedCapacityNone
  ReturnConsumedCapacityTotal
}

pub fn encode_return_consumed_capacity_enum(
  v: ReturnConsumedCapacity,
) -> json.Json {
  case v {
    ReturnConsumedCapacityIndexes -> json.string("INDEXES")
    ReturnConsumedCapacityNone -> json.string("NONE")
    ReturnConsumedCapacityTotal -> json.string("TOTAL")
  }
}

pub fn decode_return_consumed_capacity_enum() -> decode.Decoder(
  ReturnConsumedCapacity,
) {
  decode.then(decode.string, fn(s) {
    case s {
      "INDEXES" -> decode.success(ReturnConsumedCapacityIndexes)
      "NONE" -> decode.success(ReturnConsumedCapacityNone)
      "TOTAL" -> decode.success(ReturnConsumedCapacityTotal)
      _ -> decode.failure(ReturnConsumedCapacityIndexes, "unknown enum value")
    }
  })
}

pub type BatchStatementRequest {
  BatchStatementRequest(
    consistent_read: option.Option(Bool),
    parameters: option.Option(List(AttributeValue)),
    return_values_on_condition_check_failure: option.Option(
      ReturnValuesOnConditionCheckFailure,
    ),
    statement: option.Option(String),
  )
}

pub fn batch_statement_request_default() -> BatchStatementRequest {
  BatchStatementRequest(
    consistent_read: option.None,
    parameters: option.None,
    return_values_on_condition_check_failure: option.None,
    statement: option.None,
  )
}

pub fn encode_batch_statement_request_struct(
  input: BatchStatementRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.consistent_read {
    option.Some(v) -> [#("ConsistentRead", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.parameters {
    option.Some(v) -> [
      #(
        "Parameters",
        fn(xs) { json.array(xs, encode_attribute_value_union) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_values_on_condition_check_failure {
    option.Some(v) -> [
      #(
        "ReturnValuesOnConditionCheckFailure",
        encode_return_values_on_condition_check_failure_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.statement {
    option.Some(v) -> [#("Statement", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_batch_statement_request_struct_top(
  input: BatchStatementRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.consistent_read {
    option.Some(v) -> [#("ConsistentRead", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.parameters {
    option.Some(v) -> [
      #(
        "Parameters",
        fn(xs) { json.array(xs, encode_attribute_value_union) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_values_on_condition_check_failure {
    option.Some(v) -> [
      #(
        "ReturnValuesOnConditionCheckFailure",
        encode_return_values_on_condition_check_failure_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.statement {
    option.Some(v) -> [#("Statement", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_batch_statement_request_struct() -> decode.Decoder(
  BatchStatementRequest,
) {
  use <- decode.recursive
  use consistent_read <- decode.optional_field(
    "ConsistentRead",
    option.None,
    decode.optional(decode.bool),
  )
  use parameters <- decode.optional_field(
    "Parameters",
    option.None,
    decode.optional(decode.list(decode_attribute_value_union())),
  )
  use return_values_on_condition_check_failure <- decode.optional_field(
    "ReturnValuesOnConditionCheckFailure",
    option.None,
    decode.optional(decode_return_values_on_condition_check_failure_enum()),
  )
  use statement <- decode.optional_field(
    "Statement",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(BatchStatementRequest(
    consistent_read: consistent_read,
    parameters: parameters,
    return_values_on_condition_check_failure: return_values_on_condition_check_failure,
    statement: statement,
  ))
}

pub type AttributeValue {
  AttributeValueB(BitArray)
  AttributeValueBOOL(Bool)
  AttributeValueBS(List(BitArray))
  AttributeValueL(List(AttributeValue))
  AttributeValueM(dict.Dict(String, AttributeValue))
  AttributeValueN(String)
  AttributeValueNS(List(String))
  AttributeValueNULL(Bool)
  AttributeValueS(String)
  AttributeValueSS(List(String))
}

pub fn encode_attribute_value_union(v: AttributeValue) -> json.Json {
  case v {
    AttributeValueB(x) ->
      json.object([
        #("B", fn(b) { json.string(bit_array.base64_encode(b, True)) }(x)),
      ])
    AttributeValueBOOL(x) -> json.object([#("BOOL", json.bool(x))])
    AttributeValueBS(x) ->
      json.object([
        #(
          "BS",
          fn(xs) {
            json.array(xs, fn(b) {
              json.string(bit_array.base64_encode(b, True))
            })
          }(x),
        ),
      ])
    AttributeValueL(x) ->
      json.object([
        #("L", fn(xs) { json.array(xs, encode_attribute_value_union) }(x)),
      ])
    AttributeValueM(x) ->
      json.object([
        #(
          "M",
          fn(d) {
            json.object(
              dict.to_list(d)
              |> list.map(fn(pair) {
                #(pair.0, encode_attribute_value_union(pair.1))
              }),
            )
          }(x),
        ),
      ])
    AttributeValueN(x) -> json.object([#("N", json.string(x))])
    AttributeValueNS(x) ->
      json.object([#("NS", fn(xs) { json.array(xs, json.string) }(x))])
    AttributeValueNULL(x) -> json.object([#("NULL", json.bool(x))])
    AttributeValueS(x) -> json.object([#("S", json.string(x))])
    AttributeValueSS(x) ->
      json.object([#("SS", fn(xs) { json.array(xs, json.string) }(x))])
  }
}

pub fn decode_attribute_value_union() -> decode.Decoder(AttributeValue) {
  use <- decode.recursive
  decode.one_of(
    decode.field(
      "B",
      decode.then(decode.string, fn(s) {
        decode.success(bit_array.from_string(s))
      }),
      fn(x) { decode.success(AttributeValueB(x)) },
    ),
    [
      decode.field("BOOL", decode.bool, fn(x) {
        decode.success(AttributeValueBOOL(x))
      }),
      decode.field(
        "BS",
        decode.list(
          decode.then(decode.string, fn(s) {
            decode.success(bit_array.from_string(s))
          }),
        ),
        fn(x) { decode.success(AttributeValueBS(x)) },
      ),
      decode.field("L", decode.list(decode_attribute_value_union()), fn(x) {
        decode.success(AttributeValueL(x))
      }),
      decode.field(
        "M",
        decode.dict(decode.string, decode_attribute_value_union()),
        fn(x) { decode.success(AttributeValueM(x)) },
      ),
      decode.field("N", decode.string, fn(x) {
        decode.success(AttributeValueN(x))
      }),
      decode.field("NS", decode.list(decode.string), fn(x) {
        decode.success(AttributeValueNS(x))
      }),
      decode.field("NULL", decode.bool, fn(x) {
        decode.success(AttributeValueNULL(x))
      }),
      decode.field("S", decode.string, fn(x) {
        decode.success(AttributeValueS(x))
      }),
      decode.field("SS", decode.list(decode.string), fn(x) {
        decode.success(AttributeValueSS(x))
      }),
    ],
  )
}

pub type ReturnValuesOnConditionCheckFailure {
  ReturnValuesOnConditionCheckFailureAllOld
  ReturnValuesOnConditionCheckFailureNone
}

pub fn encode_return_values_on_condition_check_failure_enum(
  v: ReturnValuesOnConditionCheckFailure,
) -> json.Json {
  case v {
    ReturnValuesOnConditionCheckFailureAllOld -> json.string("ALL_OLD")
    ReturnValuesOnConditionCheckFailureNone -> json.string("NONE")
  }
}

pub fn decode_return_values_on_condition_check_failure_enum() -> decode.Decoder(
  ReturnValuesOnConditionCheckFailure,
) {
  decode.then(decode.string, fn(s) {
    case s {
      "ALL_OLD" -> decode.success(ReturnValuesOnConditionCheckFailureAllOld)
      "NONE" -> decode.success(ReturnValuesOnConditionCheckFailureNone)
      _ ->
        decode.failure(
          ReturnValuesOnConditionCheckFailureAllOld,
          "unknown enum value",
        )
    }
  })
}

pub type BatchExecuteStatementOutput {
  BatchExecuteStatementOutput(
    consumed_capacity: option.Option(List(ConsumedCapacity)),
    responses: option.Option(List(BatchStatementResponse)),
  )
}

pub fn batch_execute_statement_output_default() -> BatchExecuteStatementOutput {
  BatchExecuteStatementOutput(
    consumed_capacity: option.None,
    responses: option.None,
  )
}

pub fn encode_batch_execute_statement_output_struct(
  input: BatchExecuteStatementOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.consumed_capacity {
    option.Some(v) -> [
      #(
        "ConsumedCapacity",
        fn(xs) { json.array(xs, encode_consumed_capacity_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.responses {
    option.Some(v) -> [
      #(
        "Responses",
        fn(xs) { json.array(xs, encode_batch_statement_response_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_batch_execute_statement_output_struct_top(
  input: BatchExecuteStatementOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.consumed_capacity {
    option.Some(v) -> [
      #(
        "ConsumedCapacity",
        fn(xs) { json.array(xs, encode_consumed_capacity_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.responses {
    option.Some(v) -> [
      #(
        "Responses",
        fn(xs) { json.array(xs, encode_batch_statement_response_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_batch_execute_statement_output_struct() -> decode.Decoder(
  BatchExecuteStatementOutput,
) {
  use <- decode.recursive
  use consumed_capacity <- decode.optional_field(
    "ConsumedCapacity",
    option.None,
    decode.optional(decode.list(decode_consumed_capacity_struct())),
  )
  use responses <- decode.optional_field(
    "Responses",
    option.None,
    decode.optional(decode.list(decode_batch_statement_response_struct())),
  )
  decode.success(BatchExecuteStatementOutput(
    consumed_capacity: consumed_capacity,
    responses: responses,
  ))
}

pub type ConsumedCapacity {
  ConsumedCapacity(
    capacity_units: option.Option(json_float.SmithyFloat),
    global_secondary_indexes: option.Option(dict.Dict(String, Capacity)),
    local_secondary_indexes: option.Option(dict.Dict(String, Capacity)),
    read_capacity_units: option.Option(json_float.SmithyFloat),
    table: option.Option(Capacity),
    table_name: option.Option(String),
    write_capacity_units: option.Option(json_float.SmithyFloat),
  )
}

pub fn consumed_capacity_default() -> ConsumedCapacity {
  ConsumedCapacity(
    capacity_units: option.None,
    global_secondary_indexes: option.None,
    local_secondary_indexes: option.None,
    read_capacity_units: option.None,
    table: option.None,
    table_name: option.None,
    write_capacity_units: option.None,
  )
}

pub fn encode_consumed_capacity_struct(input: ConsumedCapacity) -> json.Json {
  let pairs = []
  let pairs = case input.capacity_units {
    option.Some(v) -> [#("CapacityUnits", json_float.encode(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.global_secondary_indexes {
    option.Some(v) -> [
      #(
        "GlobalSecondaryIndexes",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, encode_capacity_struct(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.local_secondary_indexes {
    option.Some(v) -> [
      #(
        "LocalSecondaryIndexes",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, encode_capacity_struct(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.read_capacity_units {
    option.Some(v) -> [#("ReadCapacityUnits", json_float.encode(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table {
    option.Some(v) -> [#("Table", encode_capacity_struct(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.write_capacity_units {
    option.Some(v) -> [#("WriteCapacityUnits", json_float.encode(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_consumed_capacity_struct_top(
  input: ConsumedCapacity,
) -> json.Json {
  let pairs = []
  let pairs = case input.capacity_units {
    option.Some(v) -> [#("CapacityUnits", json_float.encode(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.global_secondary_indexes {
    option.Some(v) -> [
      #(
        "GlobalSecondaryIndexes",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, encode_capacity_struct(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.local_secondary_indexes {
    option.Some(v) -> [
      #(
        "LocalSecondaryIndexes",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, encode_capacity_struct(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.read_capacity_units {
    option.Some(v) -> [#("ReadCapacityUnits", json_float.encode(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table {
    option.Some(v) -> [#("Table", encode_capacity_struct(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.write_capacity_units {
    option.Some(v) -> [#("WriteCapacityUnits", json_float.encode(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_consumed_capacity_struct() -> decode.Decoder(ConsumedCapacity) {
  use <- decode.recursive
  use capacity_units <- decode.optional_field(
    "CapacityUnits",
    option.None,
    decode.optional(json_float.decoder()),
  )
  use global_secondary_indexes <- decode.optional_field(
    "GlobalSecondaryIndexes",
    option.None,
    decode.optional(decode.dict(decode.string, decode_capacity_struct())),
  )
  use local_secondary_indexes <- decode.optional_field(
    "LocalSecondaryIndexes",
    option.None,
    decode.optional(decode.dict(decode.string, decode_capacity_struct())),
  )
  use read_capacity_units <- decode.optional_field(
    "ReadCapacityUnits",
    option.None,
    decode.optional(json_float.decoder()),
  )
  use table <- decode.optional_field(
    "Table",
    option.None,
    decode.optional(decode_capacity_struct()),
  )
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  use write_capacity_units <- decode.optional_field(
    "WriteCapacityUnits",
    option.None,
    decode.optional(json_float.decoder()),
  )
  decode.success(ConsumedCapacity(
    capacity_units: capacity_units,
    global_secondary_indexes: global_secondary_indexes,
    local_secondary_indexes: local_secondary_indexes,
    read_capacity_units: read_capacity_units,
    table: table,
    table_name: table_name,
    write_capacity_units: write_capacity_units,
  ))
}

pub type Capacity {
  Capacity(
    capacity_units: option.Option(json_float.SmithyFloat),
    read_capacity_units: option.Option(json_float.SmithyFloat),
    write_capacity_units: option.Option(json_float.SmithyFloat),
  )
}

pub fn capacity_default() -> Capacity {
  Capacity(
    capacity_units: option.None,
    read_capacity_units: option.None,
    write_capacity_units: option.None,
  )
}

pub fn encode_capacity_struct(input: Capacity) -> json.Json {
  let pairs = []
  let pairs = case input.capacity_units {
    option.Some(v) -> [#("CapacityUnits", json_float.encode(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.read_capacity_units {
    option.Some(v) -> [#("ReadCapacityUnits", json_float.encode(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.write_capacity_units {
    option.Some(v) -> [#("WriteCapacityUnits", json_float.encode(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_capacity_struct_top(input: Capacity) -> json.Json {
  let pairs = []
  let pairs = case input.capacity_units {
    option.Some(v) -> [#("CapacityUnits", json_float.encode(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.read_capacity_units {
    option.Some(v) -> [#("ReadCapacityUnits", json_float.encode(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.write_capacity_units {
    option.Some(v) -> [#("WriteCapacityUnits", json_float.encode(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_capacity_struct() -> decode.Decoder(Capacity) {
  use <- decode.recursive
  use capacity_units <- decode.optional_field(
    "CapacityUnits",
    option.None,
    decode.optional(json_float.decoder()),
  )
  use read_capacity_units <- decode.optional_field(
    "ReadCapacityUnits",
    option.None,
    decode.optional(json_float.decoder()),
  )
  use write_capacity_units <- decode.optional_field(
    "WriteCapacityUnits",
    option.None,
    decode.optional(json_float.decoder()),
  )
  decode.success(Capacity(
    capacity_units: capacity_units,
    read_capacity_units: read_capacity_units,
    write_capacity_units: write_capacity_units,
  ))
}

pub type BatchStatementResponse {
  BatchStatementResponse(
    error: option.Option(BatchStatementError),
    item: option.Option(dict.Dict(String, AttributeValue)),
    table_name: option.Option(String),
  )
}

pub fn batch_statement_response_default() -> BatchStatementResponse {
  BatchStatementResponse(
    error: option.None,
    item: option.None,
    table_name: option.None,
  )
}

pub fn encode_batch_statement_response_struct(
  input: BatchStatementResponse,
) -> json.Json {
  let pairs = []
  let pairs = case input.error {
    option.Some(v) -> [
      #("Error", encode_batch_statement_error_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.item {
    option.Some(v) -> [
      #(
        "Item",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_batch_statement_response_struct_top(
  input: BatchStatementResponse,
) -> json.Json {
  let pairs = []
  let pairs = case input.error {
    option.Some(v) -> [
      #("Error", encode_batch_statement_error_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.item {
    option.Some(v) -> [
      #(
        "Item",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_batch_statement_response_struct() -> decode.Decoder(
  BatchStatementResponse,
) {
  use <- decode.recursive
  use error <- decode.optional_field(
    "Error",
    option.None,
    decode.optional(decode_batch_statement_error_struct()),
  )
  use item <- decode.optional_field(
    "Item",
    option.None,
    decode.optional(decode.dict(decode.string, decode_attribute_value_union())),
  )
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(BatchStatementResponse(
    error: error,
    item: item,
    table_name: table_name,
  ))
}

pub type BatchStatementError {
  BatchStatementError(
    code: option.Option(BatchStatementErrorCodeEnum),
    item: option.Option(dict.Dict(String, AttributeValue)),
    message: option.Option(String),
  )
}

pub fn batch_statement_error_default() -> BatchStatementError {
  BatchStatementError(
    code: option.None,
    item: option.None,
    message: option.None,
  )
}

pub fn encode_batch_statement_error_struct(
  input: BatchStatementError,
) -> json.Json {
  let pairs = []
  let pairs = case input.code {
    option.Some(v) -> [
      #("Code", encode_batch_statement_error_code_enum_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.item {
    option.Some(v) -> [
      #(
        "Item",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.message {
    option.Some(v) -> [#("Message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_batch_statement_error_struct_top(
  input: BatchStatementError,
) -> json.Json {
  let pairs = []
  let pairs = case input.code {
    option.Some(v) -> [
      #("Code", encode_batch_statement_error_code_enum_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.item {
    option.Some(v) -> [
      #(
        "Item",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.message {
    option.Some(v) -> [#("Message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_batch_statement_error_struct() -> decode.Decoder(
  BatchStatementError,
) {
  use <- decode.recursive
  use code <- decode.optional_field(
    "Code",
    option.None,
    decode.optional(decode_batch_statement_error_code_enum_enum()),
  )
  use item <- decode.optional_field(
    "Item",
    option.None,
    decode.optional(decode.dict(decode.string, decode_attribute_value_union())),
  )
  use message <- decode.optional_field(
    "Message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(BatchStatementError(code: code, item: item, message: message))
}

pub type BatchStatementErrorCodeEnum {
  BatchStatementErrorCodeEnumAccessdenied
  BatchStatementErrorCodeEnumConditionalcheckfailed
  BatchStatementErrorCodeEnumDuplicateitem
  BatchStatementErrorCodeEnumInternalservererror
  BatchStatementErrorCodeEnumItemcollectionsizelimitexceeded
  BatchStatementErrorCodeEnumProvisionedthroughputexceeded
  BatchStatementErrorCodeEnumRequestlimitexceeded
  BatchStatementErrorCodeEnumResourcenotfound
  BatchStatementErrorCodeEnumThrottlingerror
  BatchStatementErrorCodeEnumTransactionconflict
  BatchStatementErrorCodeEnumValidationerror
}

pub fn encode_batch_statement_error_code_enum_enum(
  v: BatchStatementErrorCodeEnum,
) -> json.Json {
  case v {
    BatchStatementErrorCodeEnumAccessdenied -> json.string("AccessDenied")
    BatchStatementErrorCodeEnumConditionalcheckfailed ->
      json.string("ConditionalCheckFailed")
    BatchStatementErrorCodeEnumDuplicateitem -> json.string("DuplicateItem")
    BatchStatementErrorCodeEnumInternalservererror ->
      json.string("InternalServerError")
    BatchStatementErrorCodeEnumItemcollectionsizelimitexceeded ->
      json.string("ItemCollectionSizeLimitExceeded")
    BatchStatementErrorCodeEnumProvisionedthroughputexceeded ->
      json.string("ProvisionedThroughputExceeded")
    BatchStatementErrorCodeEnumRequestlimitexceeded ->
      json.string("RequestLimitExceeded")
    BatchStatementErrorCodeEnumResourcenotfound ->
      json.string("ResourceNotFound")
    BatchStatementErrorCodeEnumThrottlingerror -> json.string("ThrottlingError")
    BatchStatementErrorCodeEnumTransactionconflict ->
      json.string("TransactionConflict")
    BatchStatementErrorCodeEnumValidationerror -> json.string("ValidationError")
  }
}

pub fn decode_batch_statement_error_code_enum_enum() -> decode.Decoder(
  BatchStatementErrorCodeEnum,
) {
  decode.then(decode.string, fn(s) {
    case s {
      "AccessDenied" -> decode.success(BatchStatementErrorCodeEnumAccessdenied)
      "ConditionalCheckFailed" ->
        decode.success(BatchStatementErrorCodeEnumConditionalcheckfailed)
      "DuplicateItem" ->
        decode.success(BatchStatementErrorCodeEnumDuplicateitem)
      "InternalServerError" ->
        decode.success(BatchStatementErrorCodeEnumInternalservererror)
      "ItemCollectionSizeLimitExceeded" ->
        decode.success(
          BatchStatementErrorCodeEnumItemcollectionsizelimitexceeded,
        )
      "ProvisionedThroughputExceeded" ->
        decode.success(BatchStatementErrorCodeEnumProvisionedthroughputexceeded)
      "RequestLimitExceeded" ->
        decode.success(BatchStatementErrorCodeEnumRequestlimitexceeded)
      "ResourceNotFound" ->
        decode.success(BatchStatementErrorCodeEnumResourcenotfound)
      "ThrottlingError" ->
        decode.success(BatchStatementErrorCodeEnumThrottlingerror)
      "TransactionConflict" ->
        decode.success(BatchStatementErrorCodeEnumTransactionconflict)
      "ValidationError" ->
        decode.success(BatchStatementErrorCodeEnumValidationerror)
      _ ->
        decode.failure(
          BatchStatementErrorCodeEnumAccessdenied,
          "unknown enum value",
        )
    }
  })
}

pub type InternalServerError {
  InternalServerError(message: option.Option(String))
}

pub fn internal_server_error_default() -> InternalServerError {
  InternalServerError(message: option.None)
}

pub fn encode_internal_server_error_struct(
  input: InternalServerError,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_internal_server_error_struct_top(
  input: InternalServerError,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_internal_server_error_struct() -> decode.Decoder(
  InternalServerError,
) {
  use <- decode.recursive
  use message <- decode.optional_field(
    "message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(InternalServerError(message: message))
}

pub type RequestLimitExceeded {
  RequestLimitExceeded(
    throttling_reasons: option.Option(List(ThrottlingReason)),
    message: option.Option(String),
  )
}

pub fn request_limit_exceeded_default() -> RequestLimitExceeded {
  RequestLimitExceeded(throttling_reasons: option.None, message: option.None)
}

pub fn encode_request_limit_exceeded_struct(
  input: RequestLimitExceeded,
) -> json.Json {
  let pairs = []
  let pairs = case input.throttling_reasons {
    option.Some(v) -> [
      #(
        "ThrottlingReasons",
        fn(xs) { json.array(xs, encode_throttling_reason_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_request_limit_exceeded_struct_top(
  input: RequestLimitExceeded,
) -> json.Json {
  let pairs = []
  let pairs = case input.throttling_reasons {
    option.Some(v) -> [
      #(
        "ThrottlingReasons",
        fn(xs) { json.array(xs, encode_throttling_reason_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_request_limit_exceeded_struct() -> decode.Decoder(
  RequestLimitExceeded,
) {
  use <- decode.recursive
  use throttling_reasons <- decode.optional_field(
    "ThrottlingReasons",
    option.None,
    decode.optional(decode.list(decode_throttling_reason_struct())),
  )
  use message <- decode.optional_field(
    "message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(RequestLimitExceeded(
    throttling_reasons: throttling_reasons,
    message: message,
  ))
}

pub type ThrottlingReason {
  ThrottlingReason(
    reason: option.Option(String),
    resource: option.Option(String),
  )
}

pub fn throttling_reason_default() -> ThrottlingReason {
  ThrottlingReason(reason: option.None, resource: option.None)
}

pub fn encode_throttling_reason_struct(input: ThrottlingReason) -> json.Json {
  let pairs = []
  let pairs = case input.reason {
    option.Some(v) -> [#("reason", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.resource {
    option.Some(v) -> [#("resource", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_throttling_reason_struct_top(
  input: ThrottlingReason,
) -> json.Json {
  let pairs = []
  let pairs = case input.reason {
    option.Some(v) -> [#("reason", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.resource {
    option.Some(v) -> [#("resource", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_throttling_reason_struct() -> decode.Decoder(ThrottlingReason) {
  use <- decode.recursive
  use reason <- decode.optional_field(
    "reason",
    option.None,
    decode.optional(decode.string),
  )
  use resource <- decode.optional_field(
    "resource",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ThrottlingReason(reason: reason, resource: resource))
}

pub type ThrottlingException {
  ThrottlingException(
    message: option.Option(String),
    throttling_reasons: option.Option(List(ThrottlingReason)),
  )
}

pub fn throttling_exception_default() -> ThrottlingException {
  ThrottlingException(message: option.None, throttling_reasons: option.None)
}

pub fn encode_throttling_exception_struct(
  input: ThrottlingException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.throttling_reasons {
    option.Some(v) -> [
      #(
        "throttlingReasons",
        fn(xs) { json.array(xs, encode_throttling_reason_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_throttling_exception_struct_top(
  input: ThrottlingException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.throttling_reasons {
    option.Some(v) -> [
      #(
        "throttlingReasons",
        fn(xs) { json.array(xs, encode_throttling_reason_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_throttling_exception_struct() -> decode.Decoder(
  ThrottlingException,
) {
  use <- decode.recursive
  use message <- decode.optional_field(
    "message",
    option.None,
    decode.optional(decode.string),
  )
  use throttling_reasons <- decode.optional_field(
    "throttlingReasons",
    option.None,
    decode.optional(decode.list(decode_throttling_reason_struct())),
  )
  decode.success(ThrottlingException(
    message: message,
    throttling_reasons: throttling_reasons,
  ))
}

pub type BatchGetItemInput {
  BatchGetItemInput(
    request_items: option.Option(dict.Dict(String, KeysAndAttributes)),
    return_consumed_capacity: option.Option(ReturnConsumedCapacity),
  )
}

pub fn batch_get_item_input_default() -> BatchGetItemInput {
  BatchGetItemInput(
    request_items: option.None,
    return_consumed_capacity: option.None,
  )
}

pub fn encode_batch_get_item_input_struct(
  input: BatchGetItemInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.request_items {
    option.Some(v) -> [
      #(
        "RequestItems",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_keys_and_attributes_struct(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_consumed_capacity {
    option.Some(v) -> [
      #("ReturnConsumedCapacity", encode_return_consumed_capacity_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_batch_get_item_input_struct_top(
  input: BatchGetItemInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.request_items {
    option.Some(v) -> [
      #(
        "RequestItems",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_keys_and_attributes_struct(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_consumed_capacity {
    option.Some(v) -> [
      #("ReturnConsumedCapacity", encode_return_consumed_capacity_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_batch_get_item_input_struct() -> decode.Decoder(BatchGetItemInput) {
  use <- decode.recursive
  use request_items <- decode.optional_field(
    "RequestItems",
    option.None,
    decode.optional(decode.dict(
      decode.string,
      decode_keys_and_attributes_struct(),
    )),
  )
  use return_consumed_capacity <- decode.optional_field(
    "ReturnConsumedCapacity",
    option.None,
    decode.optional(decode_return_consumed_capacity_enum()),
  )
  decode.success(BatchGetItemInput(
    request_items: request_items,
    return_consumed_capacity: return_consumed_capacity,
  ))
}

pub type KeysAndAttributes {
  KeysAndAttributes(
    attributes_to_get: option.Option(List(String)),
    consistent_read: option.Option(Bool),
    expression_attribute_names: option.Option(dict.Dict(String, String)),
    keys: option.Option(List(dict.Dict(String, AttributeValue))),
    projection_expression: option.Option(String),
  )
}

pub fn keys_and_attributes_default() -> KeysAndAttributes {
  KeysAndAttributes(
    attributes_to_get: option.None,
    consistent_read: option.None,
    expression_attribute_names: option.None,
    keys: option.None,
    projection_expression: option.None,
  )
}

pub fn encode_keys_and_attributes_struct(
  input: KeysAndAttributes,
) -> json.Json {
  let pairs = []
  let pairs = case input.attributes_to_get {
    option.Some(v) -> [
      #("AttributesToGet", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.consistent_read {
    option.Some(v) -> [#("ConsistentRead", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_names {
    option.Some(v) -> [
      #(
        "ExpressionAttributeNames",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.keys {
    option.Some(v) -> [
      #(
        "Keys",
        fn(xs) {
          json.array(xs, fn(d) {
            json.object(
              dict.to_list(d)
              |> list.map(fn(pair) {
                #(pair.0, encode_attribute_value_union(pair.1))
              }),
            )
          })
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.projection_expression {
    option.Some(v) -> [#("ProjectionExpression", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_keys_and_attributes_struct_top(
  input: KeysAndAttributes,
) -> json.Json {
  let pairs = []
  let pairs = case input.attributes_to_get {
    option.Some(v) -> [
      #("AttributesToGet", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.consistent_read {
    option.Some(v) -> [#("ConsistentRead", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_names {
    option.Some(v) -> [
      #(
        "ExpressionAttributeNames",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.keys {
    option.Some(v) -> [
      #(
        "Keys",
        fn(xs) {
          json.array(xs, fn(d) {
            json.object(
              dict.to_list(d)
              |> list.map(fn(pair) {
                #(pair.0, encode_attribute_value_union(pair.1))
              }),
            )
          })
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.projection_expression {
    option.Some(v) -> [#("ProjectionExpression", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_keys_and_attributes_struct() -> decode.Decoder(KeysAndAttributes) {
  use <- decode.recursive
  use attributes_to_get <- decode.optional_field(
    "AttributesToGet",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  use consistent_read <- decode.optional_field(
    "ConsistentRead",
    option.None,
    decode.optional(decode.bool),
  )
  use expression_attribute_names <- decode.optional_field(
    "ExpressionAttributeNames",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use keys <- decode.optional_field(
    "Keys",
    option.None,
    decode.optional(
      decode.list(decode.dict(decode.string, decode_attribute_value_union())),
    ),
  )
  use projection_expression <- decode.optional_field(
    "ProjectionExpression",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(KeysAndAttributes(
    attributes_to_get: attributes_to_get,
    consistent_read: consistent_read,
    expression_attribute_names: expression_attribute_names,
    keys: keys,
    projection_expression: projection_expression,
  ))
}

pub type BatchGetItemOutput {
  BatchGetItemOutput(
    consumed_capacity: option.Option(List(ConsumedCapacity)),
    responses: option.Option(
      dict.Dict(String, List(dict.Dict(String, AttributeValue))),
    ),
    unprocessed_keys: option.Option(dict.Dict(String, KeysAndAttributes)),
  )
}

pub fn batch_get_item_output_default() -> BatchGetItemOutput {
  BatchGetItemOutput(
    consumed_capacity: option.None,
    responses: option.None,
    unprocessed_keys: option.None,
  )
}

pub fn encode_batch_get_item_output_struct(
  input: BatchGetItemOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.consumed_capacity {
    option.Some(v) -> [
      #(
        "ConsumedCapacity",
        fn(xs) { json.array(xs, encode_consumed_capacity_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.responses {
    option.Some(v) -> [
      #(
        "Responses",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(
                pair.0,
                fn(xs) {
                  json.array(xs, fn(d) {
                    json.object(
                      dict.to_list(d)
                      |> list.map(fn(pair) {
                        #(pair.0, encode_attribute_value_union(pair.1))
                      }),
                    )
                  })
                }(pair.1),
              )
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.unprocessed_keys {
    option.Some(v) -> [
      #(
        "UnprocessedKeys",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_keys_and_attributes_struct(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_batch_get_item_output_struct_top(
  input: BatchGetItemOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.consumed_capacity {
    option.Some(v) -> [
      #(
        "ConsumedCapacity",
        fn(xs) { json.array(xs, encode_consumed_capacity_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.responses {
    option.Some(v) -> [
      #(
        "Responses",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(
                pair.0,
                fn(xs) {
                  json.array(xs, fn(d) {
                    json.object(
                      dict.to_list(d)
                      |> list.map(fn(pair) {
                        #(pair.0, encode_attribute_value_union(pair.1))
                      }),
                    )
                  })
                }(pair.1),
              )
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.unprocessed_keys {
    option.Some(v) -> [
      #(
        "UnprocessedKeys",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_keys_and_attributes_struct(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_batch_get_item_output_struct() -> decode.Decoder(
  BatchGetItemOutput,
) {
  use <- decode.recursive
  use consumed_capacity <- decode.optional_field(
    "ConsumedCapacity",
    option.None,
    decode.optional(decode.list(decode_consumed_capacity_struct())),
  )
  use responses <- decode.optional_field(
    "Responses",
    option.None,
    decode.optional(decode.dict(
      decode.string,
      decode.list(decode.dict(decode.string, decode_attribute_value_union())),
    )),
  )
  use unprocessed_keys <- decode.optional_field(
    "UnprocessedKeys",
    option.None,
    decode.optional(decode.dict(
      decode.string,
      decode_keys_and_attributes_struct(),
    )),
  )
  decode.success(BatchGetItemOutput(
    consumed_capacity: consumed_capacity,
    responses: responses,
    unprocessed_keys: unprocessed_keys,
  ))
}

pub type InvalidEndpointException {
  InvalidEndpointException(message: option.Option(String))
}

pub fn invalid_endpoint_exception_default() -> InvalidEndpointException {
  InvalidEndpointException(message: option.None)
}

pub fn encode_invalid_endpoint_exception_struct(
  input: InvalidEndpointException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("Message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_invalid_endpoint_exception_struct_top(
  input: InvalidEndpointException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("Message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_invalid_endpoint_exception_struct() -> decode.Decoder(
  InvalidEndpointException,
) {
  use <- decode.recursive
  use message <- decode.optional_field(
    "Message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(InvalidEndpointException(message: message))
}

pub type ProvisionedThroughputExceededException {
  ProvisionedThroughputExceededException(
    throttling_reasons: option.Option(List(ThrottlingReason)),
    message: option.Option(String),
  )
}

pub fn provisioned_throughput_exceeded_exception_default() -> ProvisionedThroughputExceededException {
  ProvisionedThroughputExceededException(
    throttling_reasons: option.None,
    message: option.None,
  )
}

pub fn encode_provisioned_throughput_exceeded_exception_struct(
  input: ProvisionedThroughputExceededException,
) -> json.Json {
  let pairs = []
  let pairs = case input.throttling_reasons {
    option.Some(v) -> [
      #(
        "ThrottlingReasons",
        fn(xs) { json.array(xs, encode_throttling_reason_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_provisioned_throughput_exceeded_exception_struct_top(
  input: ProvisionedThroughputExceededException,
) -> json.Json {
  let pairs = []
  let pairs = case input.throttling_reasons {
    option.Some(v) -> [
      #(
        "ThrottlingReasons",
        fn(xs) { json.array(xs, encode_throttling_reason_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_provisioned_throughput_exceeded_exception_struct() -> decode.Decoder(
  ProvisionedThroughputExceededException,
) {
  use <- decode.recursive
  use throttling_reasons <- decode.optional_field(
    "ThrottlingReasons",
    option.None,
    decode.optional(decode.list(decode_throttling_reason_struct())),
  )
  use message <- decode.optional_field(
    "message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ProvisionedThroughputExceededException(
    throttling_reasons: throttling_reasons,
    message: message,
  ))
}

pub type ResourceNotFoundException {
  ResourceNotFoundException(message: option.Option(String))
}

pub fn resource_not_found_exception_default() -> ResourceNotFoundException {
  ResourceNotFoundException(message: option.None)
}

pub fn encode_resource_not_found_exception_struct(
  input: ResourceNotFoundException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_resource_not_found_exception_struct_top(
  input: ResourceNotFoundException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_resource_not_found_exception_struct() -> decode.Decoder(
  ResourceNotFoundException,
) {
  use <- decode.recursive
  use message <- decode.optional_field(
    "message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ResourceNotFoundException(message: message))
}

pub type BatchWriteItemInput {
  BatchWriteItemInput(
    request_items: option.Option(dict.Dict(String, List(WriteRequest))),
    return_consumed_capacity: option.Option(ReturnConsumedCapacity),
    return_item_collection_metrics: option.Option(ReturnItemCollectionMetrics),
  )
}

pub fn batch_write_item_input_default() -> BatchWriteItemInput {
  BatchWriteItemInput(
    request_items: option.None,
    return_consumed_capacity: option.None,
    return_item_collection_metrics: option.None,
  )
}

pub fn encode_batch_write_item_input_struct(
  input: BatchWriteItemInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.request_items {
    option.Some(v) -> [
      #(
        "RequestItems",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(
                pair.0,
                fn(xs) { json.array(xs, encode_write_request_struct) }(pair.1),
              )
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_consumed_capacity {
    option.Some(v) -> [
      #("ReturnConsumedCapacity", encode_return_consumed_capacity_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_item_collection_metrics {
    option.Some(v) -> [
      #(
        "ReturnItemCollectionMetrics",
        encode_return_item_collection_metrics_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_batch_write_item_input_struct_top(
  input: BatchWriteItemInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.request_items {
    option.Some(v) -> [
      #(
        "RequestItems",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(
                pair.0,
                fn(xs) { json.array(xs, encode_write_request_struct) }(pair.1),
              )
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_consumed_capacity {
    option.Some(v) -> [
      #("ReturnConsumedCapacity", encode_return_consumed_capacity_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_item_collection_metrics {
    option.Some(v) -> [
      #(
        "ReturnItemCollectionMetrics",
        encode_return_item_collection_metrics_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_batch_write_item_input_struct() -> decode.Decoder(
  BatchWriteItemInput,
) {
  use <- decode.recursive
  use request_items <- decode.optional_field(
    "RequestItems",
    option.None,
    decode.optional(decode.dict(
      decode.string,
      decode.list(decode_write_request_struct()),
    )),
  )
  use return_consumed_capacity <- decode.optional_field(
    "ReturnConsumedCapacity",
    option.None,
    decode.optional(decode_return_consumed_capacity_enum()),
  )
  use return_item_collection_metrics <- decode.optional_field(
    "ReturnItemCollectionMetrics",
    option.None,
    decode.optional(decode_return_item_collection_metrics_enum()),
  )
  decode.success(BatchWriteItemInput(
    request_items: request_items,
    return_consumed_capacity: return_consumed_capacity,
    return_item_collection_metrics: return_item_collection_metrics,
  ))
}

pub type WriteRequest {
  WriteRequest(
    delete_request: option.Option(DeleteRequest),
    put_request: option.Option(PutRequest),
  )
}

pub fn write_request_default() -> WriteRequest {
  WriteRequest(delete_request: option.None, put_request: option.None)
}

pub fn encode_write_request_struct(input: WriteRequest) -> json.Json {
  let pairs = []
  let pairs = case input.delete_request {
    option.Some(v) -> [
      #("DeleteRequest", encode_delete_request_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.put_request {
    option.Some(v) -> [#("PutRequest", encode_put_request_struct(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_write_request_struct_top(input: WriteRequest) -> json.Json {
  let pairs = []
  let pairs = case input.delete_request {
    option.Some(v) -> [
      #("DeleteRequest", encode_delete_request_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.put_request {
    option.Some(v) -> [#("PutRequest", encode_put_request_struct(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_write_request_struct() -> decode.Decoder(WriteRequest) {
  use <- decode.recursive
  use delete_request <- decode.optional_field(
    "DeleteRequest",
    option.None,
    decode.optional(decode_delete_request_struct()),
  )
  use put_request <- decode.optional_field(
    "PutRequest",
    option.None,
    decode.optional(decode_put_request_struct()),
  )
  decode.success(WriteRequest(
    delete_request: delete_request,
    put_request: put_request,
  ))
}

pub type DeleteRequest {
  DeleteRequest(key: option.Option(dict.Dict(String, AttributeValue)))
}

pub fn delete_request_default() -> DeleteRequest {
  DeleteRequest(key: option.None)
}

pub fn encode_delete_request_struct(input: DeleteRequest) -> json.Json {
  let pairs = []
  let pairs = case input.key {
    option.Some(v) -> [
      #(
        "Key",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_delete_request_struct_top(input: DeleteRequest) -> json.Json {
  let pairs = []
  let pairs = case input.key {
    option.Some(v) -> [
      #(
        "Key",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_delete_request_struct() -> decode.Decoder(DeleteRequest) {
  use <- decode.recursive
  use key <- decode.optional_field(
    "Key",
    option.None,
    decode.optional(decode.dict(decode.string, decode_attribute_value_union())),
  )
  decode.success(DeleteRequest(key: key))
}

pub type PutRequest {
  PutRequest(item: option.Option(dict.Dict(String, AttributeValue)))
}

pub fn put_request_default() -> PutRequest {
  PutRequest(item: option.None)
}

pub fn encode_put_request_struct(input: PutRequest) -> json.Json {
  let pairs = []
  let pairs = case input.item {
    option.Some(v) -> [
      #(
        "Item",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_put_request_struct_top(input: PutRequest) -> json.Json {
  let pairs = []
  let pairs = case input.item {
    option.Some(v) -> [
      #(
        "Item",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_put_request_struct() -> decode.Decoder(PutRequest) {
  use <- decode.recursive
  use item <- decode.optional_field(
    "Item",
    option.None,
    decode.optional(decode.dict(decode.string, decode_attribute_value_union())),
  )
  decode.success(PutRequest(item: item))
}

pub type ReturnItemCollectionMetrics {
  ReturnItemCollectionMetricsNone
  ReturnItemCollectionMetricsSize
}

pub fn encode_return_item_collection_metrics_enum(
  v: ReturnItemCollectionMetrics,
) -> json.Json {
  case v {
    ReturnItemCollectionMetricsNone -> json.string("NONE")
    ReturnItemCollectionMetricsSize -> json.string("SIZE")
  }
}

pub fn decode_return_item_collection_metrics_enum() -> decode.Decoder(
  ReturnItemCollectionMetrics,
) {
  decode.then(decode.string, fn(s) {
    case s {
      "NONE" -> decode.success(ReturnItemCollectionMetricsNone)
      "SIZE" -> decode.success(ReturnItemCollectionMetricsSize)
      _ -> decode.failure(ReturnItemCollectionMetricsNone, "unknown enum value")
    }
  })
}

pub type BatchWriteItemOutput {
  BatchWriteItemOutput(
    consumed_capacity: option.Option(List(ConsumedCapacity)),
    item_collection_metrics: option.Option(
      dict.Dict(String, List(ItemCollectionMetrics)),
    ),
    unprocessed_items: option.Option(dict.Dict(String, List(WriteRequest))),
  )
}

pub fn batch_write_item_output_default() -> BatchWriteItemOutput {
  BatchWriteItemOutput(
    consumed_capacity: option.None,
    item_collection_metrics: option.None,
    unprocessed_items: option.None,
  )
}

pub fn encode_batch_write_item_output_struct(
  input: BatchWriteItemOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.consumed_capacity {
    option.Some(v) -> [
      #(
        "ConsumedCapacity",
        fn(xs) { json.array(xs, encode_consumed_capacity_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.item_collection_metrics {
    option.Some(v) -> [
      #(
        "ItemCollectionMetrics",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(
                pair.0,
                fn(xs) { json.array(xs, encode_item_collection_metrics_struct) }(
                  pair.1,
                ),
              )
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.unprocessed_items {
    option.Some(v) -> [
      #(
        "UnprocessedItems",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(
                pair.0,
                fn(xs) { json.array(xs, encode_write_request_struct) }(pair.1),
              )
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_batch_write_item_output_struct_top(
  input: BatchWriteItemOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.consumed_capacity {
    option.Some(v) -> [
      #(
        "ConsumedCapacity",
        fn(xs) { json.array(xs, encode_consumed_capacity_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.item_collection_metrics {
    option.Some(v) -> [
      #(
        "ItemCollectionMetrics",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(
                pair.0,
                fn(xs) { json.array(xs, encode_item_collection_metrics_struct) }(
                  pair.1,
                ),
              )
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.unprocessed_items {
    option.Some(v) -> [
      #(
        "UnprocessedItems",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(
                pair.0,
                fn(xs) { json.array(xs, encode_write_request_struct) }(pair.1),
              )
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_batch_write_item_output_struct() -> decode.Decoder(
  BatchWriteItemOutput,
) {
  use <- decode.recursive
  use consumed_capacity <- decode.optional_field(
    "ConsumedCapacity",
    option.None,
    decode.optional(decode.list(decode_consumed_capacity_struct())),
  )
  use item_collection_metrics <- decode.optional_field(
    "ItemCollectionMetrics",
    option.None,
    decode.optional(decode.dict(
      decode.string,
      decode.list(decode_item_collection_metrics_struct()),
    )),
  )
  use unprocessed_items <- decode.optional_field(
    "UnprocessedItems",
    option.None,
    decode.optional(decode.dict(
      decode.string,
      decode.list(decode_write_request_struct()),
    )),
  )
  decode.success(BatchWriteItemOutput(
    consumed_capacity: consumed_capacity,
    item_collection_metrics: item_collection_metrics,
    unprocessed_items: unprocessed_items,
  ))
}

pub type ItemCollectionMetrics {
  ItemCollectionMetrics(
    item_collection_key: option.Option(dict.Dict(String, AttributeValue)),
    size_estimate_range_gb: option.Option(List(json_float.SmithyFloat)),
  )
}

pub fn item_collection_metrics_default() -> ItemCollectionMetrics {
  ItemCollectionMetrics(
    item_collection_key: option.None,
    size_estimate_range_gb: option.None,
  )
}

pub fn encode_item_collection_metrics_struct(
  input: ItemCollectionMetrics,
) -> json.Json {
  let pairs = []
  let pairs = case input.item_collection_key {
    option.Some(v) -> [
      #(
        "ItemCollectionKey",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.size_estimate_range_gb {
    option.Some(v) -> [
      #("SizeEstimateRangeGB", fn(xs) { json.array(xs, json_float.encode) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_item_collection_metrics_struct_top(
  input: ItemCollectionMetrics,
) -> json.Json {
  let pairs = []
  let pairs = case input.item_collection_key {
    option.Some(v) -> [
      #(
        "ItemCollectionKey",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.size_estimate_range_gb {
    option.Some(v) -> [
      #("SizeEstimateRangeGB", fn(xs) { json.array(xs, json_float.encode) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_item_collection_metrics_struct() -> decode.Decoder(
  ItemCollectionMetrics,
) {
  use <- decode.recursive
  use item_collection_key <- decode.optional_field(
    "ItemCollectionKey",
    option.None,
    decode.optional(decode.dict(decode.string, decode_attribute_value_union())),
  )
  use size_estimate_range_gb <- decode.optional_field(
    "SizeEstimateRangeGB",
    option.None,
    decode.optional(decode.list(json_float.decoder())),
  )
  decode.success(ItemCollectionMetrics(
    item_collection_key: item_collection_key,
    size_estimate_range_gb: size_estimate_range_gb,
  ))
}

pub type ItemCollectionSizeLimitExceededException {
  ItemCollectionSizeLimitExceededException(message: option.Option(String))
}

pub fn item_collection_size_limit_exceeded_exception_default() -> ItemCollectionSizeLimitExceededException {
  ItemCollectionSizeLimitExceededException(message: option.None)
}

pub fn encode_item_collection_size_limit_exceeded_exception_struct(
  input: ItemCollectionSizeLimitExceededException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_item_collection_size_limit_exceeded_exception_struct_top(
  input: ItemCollectionSizeLimitExceededException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_item_collection_size_limit_exceeded_exception_struct() -> decode.Decoder(
  ItemCollectionSizeLimitExceededException,
) {
  use <- decode.recursive
  use message <- decode.optional_field(
    "message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ItemCollectionSizeLimitExceededException(message: message))
}

pub type ReplicatedWriteConflictException {
  ReplicatedWriteConflictException(message: option.Option(String))
}

pub fn replicated_write_conflict_exception_default() -> ReplicatedWriteConflictException {
  ReplicatedWriteConflictException(message: option.None)
}

pub fn encode_replicated_write_conflict_exception_struct(
  input: ReplicatedWriteConflictException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_replicated_write_conflict_exception_struct_top(
  input: ReplicatedWriteConflictException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_replicated_write_conflict_exception_struct() -> decode.Decoder(
  ReplicatedWriteConflictException,
) {
  use <- decode.recursive
  use message <- decode.optional_field(
    "message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ReplicatedWriteConflictException(message: message))
}

pub type CreateBackupInput {
  CreateBackupInput(
    backup_name: option.Option(String),
    table_name: option.Option(String),
  )
}

pub fn create_backup_input_default() -> CreateBackupInput {
  CreateBackupInput(backup_name: option.None, table_name: option.None)
}

pub fn encode_create_backup_input_struct(
  input: CreateBackupInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.backup_name {
    option.Some(v) -> [#("BackupName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_create_backup_input_struct_top(
  input: CreateBackupInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.backup_name {
    option.Some(v) -> [#("BackupName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_create_backup_input_struct() -> decode.Decoder(CreateBackupInput) {
  use <- decode.recursive
  use backup_name <- decode.optional_field(
    "BackupName",
    option.None,
    decode.optional(decode.string),
  )
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(CreateBackupInput(
    backup_name: backup_name,
    table_name: table_name,
  ))
}

pub type CreateBackupOutput {
  CreateBackupOutput(backup_details: option.Option(BackupDetails))
}

pub fn create_backup_output_default() -> CreateBackupOutput {
  CreateBackupOutput(backup_details: option.None)
}

pub fn encode_create_backup_output_struct(
  input: CreateBackupOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.backup_details {
    option.Some(v) -> [
      #("BackupDetails", encode_backup_details_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_create_backup_output_struct_top(
  input: CreateBackupOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.backup_details {
    option.Some(v) -> [
      #("BackupDetails", encode_backup_details_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_create_backup_output_struct() -> decode.Decoder(
  CreateBackupOutput,
) {
  use <- decode.recursive
  use backup_details <- decode.optional_field(
    "BackupDetails",
    option.None,
    decode.optional(decode_backup_details_struct()),
  )
  decode.success(CreateBackupOutput(backup_details: backup_details))
}

pub type BackupDetails {
  BackupDetails(
    backup_arn: option.Option(String),
    backup_creation_date_time: option.Option(json_timestamp.Timestamp),
    backup_expiry_date_time: option.Option(json_timestamp.Timestamp),
    backup_name: option.Option(String),
    backup_size_bytes: option.Option(Int),
    backup_status: option.Option(BackupStatus),
    backup_type: option.Option(BackupType),
  )
}

pub fn backup_details_default() -> BackupDetails {
  BackupDetails(
    backup_arn: option.None,
    backup_creation_date_time: option.None,
    backup_expiry_date_time: option.None,
    backup_name: option.None,
    backup_size_bytes: option.None,
    backup_status: option.None,
    backup_type: option.None,
  )
}

pub fn encode_backup_details_struct(input: BackupDetails) -> json.Json {
  let pairs = []
  let pairs = case input.backup_arn {
    option.Some(v) -> [#("BackupArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.backup_creation_date_time {
    option.Some(v) -> [
      #("BackupCreationDateTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.backup_expiry_date_time {
    option.Some(v) -> [
      #("BackupExpiryDateTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.backup_name {
    option.Some(v) -> [#("BackupName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.backup_size_bytes {
    option.Some(v) -> [#("BackupSizeBytes", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.backup_status {
    option.Some(v) -> [#("BackupStatus", encode_backup_status_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.backup_type {
    option.Some(v) -> [#("BackupType", encode_backup_type_enum(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_backup_details_struct_top(input: BackupDetails) -> json.Json {
  let pairs = []
  let pairs = case input.backup_arn {
    option.Some(v) -> [#("BackupArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.backup_creation_date_time {
    option.Some(v) -> [
      #("BackupCreationDateTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.backup_expiry_date_time {
    option.Some(v) -> [
      #("BackupExpiryDateTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.backup_name {
    option.Some(v) -> [#("BackupName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.backup_size_bytes {
    option.Some(v) -> [#("BackupSizeBytes", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.backup_status {
    option.Some(v) -> [#("BackupStatus", encode_backup_status_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.backup_type {
    option.Some(v) -> [#("BackupType", encode_backup_type_enum(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_backup_details_struct() -> decode.Decoder(BackupDetails) {
  use <- decode.recursive
  use backup_arn <- decode.optional_field(
    "BackupArn",
    option.None,
    decode.optional(decode.string),
  )
  use backup_creation_date_time <- decode.optional_field(
    "BackupCreationDateTime",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use backup_expiry_date_time <- decode.optional_field(
    "BackupExpiryDateTime",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use backup_name <- decode.optional_field(
    "BackupName",
    option.None,
    decode.optional(decode.string),
  )
  use backup_size_bytes <- decode.optional_field(
    "BackupSizeBytes",
    option.None,
    decode.optional(decode.int),
  )
  use backup_status <- decode.optional_field(
    "BackupStatus",
    option.None,
    decode.optional(decode_backup_status_enum()),
  )
  use backup_type <- decode.optional_field(
    "BackupType",
    option.None,
    decode.optional(decode_backup_type_enum()),
  )
  decode.success(BackupDetails(
    backup_arn: backup_arn,
    backup_creation_date_time: backup_creation_date_time,
    backup_expiry_date_time: backup_expiry_date_time,
    backup_name: backup_name,
    backup_size_bytes: backup_size_bytes,
    backup_status: backup_status,
    backup_type: backup_type,
  ))
}

pub type BackupStatus {
  BackupStatusAvailable
  BackupStatusCreating
  BackupStatusDeleted
}

pub fn encode_backup_status_enum(v: BackupStatus) -> json.Json {
  case v {
    BackupStatusAvailable -> json.string("AVAILABLE")
    BackupStatusCreating -> json.string("CREATING")
    BackupStatusDeleted -> json.string("DELETED")
  }
}

pub fn decode_backup_status_enum() -> decode.Decoder(BackupStatus) {
  decode.then(decode.string, fn(s) {
    case s {
      "AVAILABLE" -> decode.success(BackupStatusAvailable)
      "CREATING" -> decode.success(BackupStatusCreating)
      "DELETED" -> decode.success(BackupStatusDeleted)
      _ -> decode.failure(BackupStatusAvailable, "unknown enum value")
    }
  })
}

pub type BackupType {
  BackupTypeAwsBackup
  BackupTypeSystem
  BackupTypeUser
}

pub fn encode_backup_type_enum(v: BackupType) -> json.Json {
  case v {
    BackupTypeAwsBackup -> json.string("AWS_BACKUP")
    BackupTypeSystem -> json.string("SYSTEM")
    BackupTypeUser -> json.string("USER")
  }
}

pub fn decode_backup_type_enum() -> decode.Decoder(BackupType) {
  decode.then(decode.string, fn(s) {
    case s {
      "AWS_BACKUP" -> decode.success(BackupTypeAwsBackup)
      "SYSTEM" -> decode.success(BackupTypeSystem)
      "USER" -> decode.success(BackupTypeUser)
      _ -> decode.failure(BackupTypeAwsBackup, "unknown enum value")
    }
  })
}

pub type BackupInUseException {
  BackupInUseException(message: option.Option(String))
}

pub fn backup_in_use_exception_default() -> BackupInUseException {
  BackupInUseException(message: option.None)
}

pub fn encode_backup_in_use_exception_struct(
  input: BackupInUseException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_backup_in_use_exception_struct_top(
  input: BackupInUseException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_backup_in_use_exception_struct() -> decode.Decoder(
  BackupInUseException,
) {
  use <- decode.recursive
  use message <- decode.optional_field(
    "message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(BackupInUseException(message: message))
}

pub type ContinuousBackupsUnavailableException {
  ContinuousBackupsUnavailableException(message: option.Option(String))
}

pub fn continuous_backups_unavailable_exception_default() -> ContinuousBackupsUnavailableException {
  ContinuousBackupsUnavailableException(message: option.None)
}

pub fn encode_continuous_backups_unavailable_exception_struct(
  input: ContinuousBackupsUnavailableException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_continuous_backups_unavailable_exception_struct_top(
  input: ContinuousBackupsUnavailableException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_continuous_backups_unavailable_exception_struct() -> decode.Decoder(
  ContinuousBackupsUnavailableException,
) {
  use <- decode.recursive
  use message <- decode.optional_field(
    "message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ContinuousBackupsUnavailableException(message: message))
}

pub type LimitExceededException {
  LimitExceededException(message: option.Option(String))
}

pub fn limit_exceeded_exception_default() -> LimitExceededException {
  LimitExceededException(message: option.None)
}

pub fn encode_limit_exceeded_exception_struct(
  input: LimitExceededException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_limit_exceeded_exception_struct_top(
  input: LimitExceededException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_limit_exceeded_exception_struct() -> decode.Decoder(
  LimitExceededException,
) {
  use <- decode.recursive
  use message <- decode.optional_field(
    "message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(LimitExceededException(message: message))
}

pub type TableInUseException {
  TableInUseException(message: option.Option(String))
}

pub fn table_in_use_exception_default() -> TableInUseException {
  TableInUseException(message: option.None)
}

pub fn encode_table_in_use_exception_struct(
  input: TableInUseException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_table_in_use_exception_struct_top(
  input: TableInUseException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_table_in_use_exception_struct() -> decode.Decoder(
  TableInUseException,
) {
  use <- decode.recursive
  use message <- decode.optional_field(
    "message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(TableInUseException(message: message))
}

pub type TableNotFoundException {
  TableNotFoundException(message: option.Option(String))
}

pub fn table_not_found_exception_default() -> TableNotFoundException {
  TableNotFoundException(message: option.None)
}

pub fn encode_table_not_found_exception_struct(
  input: TableNotFoundException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_table_not_found_exception_struct_top(
  input: TableNotFoundException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_table_not_found_exception_struct() -> decode.Decoder(
  TableNotFoundException,
) {
  use <- decode.recursive
  use message <- decode.optional_field(
    "message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(TableNotFoundException(message: message))
}

pub type CreateGlobalTableInput {
  CreateGlobalTableInput(
    global_table_name: option.Option(String),
    replication_group: option.Option(List(Replica)),
  )
}

pub fn create_global_table_input_default() -> CreateGlobalTableInput {
  CreateGlobalTableInput(
    global_table_name: option.None,
    replication_group: option.None,
  )
}

pub fn encode_create_global_table_input_struct(
  input: CreateGlobalTableInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.global_table_name {
    option.Some(v) -> [#("GlobalTableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.replication_group {
    option.Some(v) -> [
      #("ReplicationGroup", fn(xs) { json.array(xs, encode_replica_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_create_global_table_input_struct_top(
  input: CreateGlobalTableInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.global_table_name {
    option.Some(v) -> [#("GlobalTableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.replication_group {
    option.Some(v) -> [
      #("ReplicationGroup", fn(xs) { json.array(xs, encode_replica_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_create_global_table_input_struct() -> decode.Decoder(
  CreateGlobalTableInput,
) {
  use <- decode.recursive
  use global_table_name <- decode.optional_field(
    "GlobalTableName",
    option.None,
    decode.optional(decode.string),
  )
  use replication_group <- decode.optional_field(
    "ReplicationGroup",
    option.None,
    decode.optional(decode.list(decode_replica_struct())),
  )
  decode.success(CreateGlobalTableInput(
    global_table_name: global_table_name,
    replication_group: replication_group,
  ))
}

pub type Replica {
  Replica(region_name: option.Option(String))
}

pub fn replica_default() -> Replica {
  Replica(region_name: option.None)
}

pub fn encode_replica_struct(input: Replica) -> json.Json {
  let pairs = []
  let pairs = case input.region_name {
    option.Some(v) -> [#("RegionName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_replica_struct_top(input: Replica) -> json.Json {
  let pairs = []
  let pairs = case input.region_name {
    option.Some(v) -> [#("RegionName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_replica_struct() -> decode.Decoder(Replica) {
  use <- decode.recursive
  use region_name <- decode.optional_field(
    "RegionName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(Replica(region_name: region_name))
}

pub type CreateGlobalTableOutput {
  CreateGlobalTableOutput(
    global_table_description: option.Option(GlobalTableDescription),
  )
}

pub fn create_global_table_output_default() -> CreateGlobalTableOutput {
  CreateGlobalTableOutput(global_table_description: option.None)
}

pub fn encode_create_global_table_output_struct(
  input: CreateGlobalTableOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.global_table_description {
    option.Some(v) -> [
      #("GlobalTableDescription", encode_global_table_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_create_global_table_output_struct_top(
  input: CreateGlobalTableOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.global_table_description {
    option.Some(v) -> [
      #("GlobalTableDescription", encode_global_table_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_create_global_table_output_struct() -> decode.Decoder(
  CreateGlobalTableOutput,
) {
  use <- decode.recursive
  use global_table_description <- decode.optional_field(
    "GlobalTableDescription",
    option.None,
    decode.optional(decode_global_table_description_struct()),
  )
  decode.success(CreateGlobalTableOutput(
    global_table_description: global_table_description,
  ))
}

pub type GlobalTableDescription {
  GlobalTableDescription(
    creation_date_time: option.Option(json_timestamp.Timestamp),
    global_table_arn: option.Option(String),
    global_table_name: option.Option(String),
    global_table_status: option.Option(GlobalTableStatus),
    replication_group: option.Option(List(ReplicaDescription)),
  )
}

pub fn global_table_description_default() -> GlobalTableDescription {
  GlobalTableDescription(
    creation_date_time: option.None,
    global_table_arn: option.None,
    global_table_name: option.None,
    global_table_status: option.None,
    replication_group: option.None,
  )
}

pub fn encode_global_table_description_struct(
  input: GlobalTableDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.creation_date_time {
    option.Some(v) -> [
      #("CreationDateTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.global_table_arn {
    option.Some(v) -> [#("GlobalTableArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.global_table_name {
    option.Some(v) -> [#("GlobalTableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.global_table_status {
    option.Some(v) -> [
      #("GlobalTableStatus", encode_global_table_status_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.replication_group {
    option.Some(v) -> [
      #(
        "ReplicationGroup",
        fn(xs) { json.array(xs, encode_replica_description_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_global_table_description_struct_top(
  input: GlobalTableDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.creation_date_time {
    option.Some(v) -> [
      #("CreationDateTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.global_table_arn {
    option.Some(v) -> [#("GlobalTableArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.global_table_name {
    option.Some(v) -> [#("GlobalTableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.global_table_status {
    option.Some(v) -> [
      #("GlobalTableStatus", encode_global_table_status_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.replication_group {
    option.Some(v) -> [
      #(
        "ReplicationGroup",
        fn(xs) { json.array(xs, encode_replica_description_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_global_table_description_struct() -> decode.Decoder(
  GlobalTableDescription,
) {
  use <- decode.recursive
  use creation_date_time <- decode.optional_field(
    "CreationDateTime",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use global_table_arn <- decode.optional_field(
    "GlobalTableArn",
    option.None,
    decode.optional(decode.string),
  )
  use global_table_name <- decode.optional_field(
    "GlobalTableName",
    option.None,
    decode.optional(decode.string),
  )
  use global_table_status <- decode.optional_field(
    "GlobalTableStatus",
    option.None,
    decode.optional(decode_global_table_status_enum()),
  )
  use replication_group <- decode.optional_field(
    "ReplicationGroup",
    option.None,
    decode.optional(decode.list(decode_replica_description_struct())),
  )
  decode.success(GlobalTableDescription(
    creation_date_time: creation_date_time,
    global_table_arn: global_table_arn,
    global_table_name: global_table_name,
    global_table_status: global_table_status,
    replication_group: replication_group,
  ))
}

pub type GlobalTableStatus {
  GlobalTableStatusActive
  GlobalTableStatusCreating
  GlobalTableStatusDeleting
  GlobalTableStatusUpdating
}

pub fn encode_global_table_status_enum(v: GlobalTableStatus) -> json.Json {
  case v {
    GlobalTableStatusActive -> json.string("ACTIVE")
    GlobalTableStatusCreating -> json.string("CREATING")
    GlobalTableStatusDeleting -> json.string("DELETING")
    GlobalTableStatusUpdating -> json.string("UPDATING")
  }
}

pub fn decode_global_table_status_enum() -> decode.Decoder(GlobalTableStatus) {
  decode.then(decode.string, fn(s) {
    case s {
      "ACTIVE" -> decode.success(GlobalTableStatusActive)
      "CREATING" -> decode.success(GlobalTableStatusCreating)
      "DELETING" -> decode.success(GlobalTableStatusDeleting)
      "UPDATING" -> decode.success(GlobalTableStatusUpdating)
      _ -> decode.failure(GlobalTableStatusActive, "unknown enum value")
    }
  })
}

pub type ReplicaDescription {
  ReplicaDescription(
    global_secondary_indexes: option.Option(
      List(ReplicaGlobalSecondaryIndexDescription),
    ),
    global_table_settings_replication_mode: option.Option(
      GlobalTableSettingsReplicationMode,
    ),
    kms_master_key_id: option.Option(String),
    on_demand_throughput_override: option.Option(OnDemandThroughputOverride),
    provisioned_throughput_override: option.Option(
      ProvisionedThroughputOverride,
    ),
    region_name: option.Option(String),
    replica_arn: option.Option(String),
    replica_inaccessible_date_time: option.Option(json_timestamp.Timestamp),
    replica_status: option.Option(ReplicaStatus),
    replica_status_description: option.Option(String),
    replica_status_percent_progress: option.Option(String),
    replica_table_class_summary: option.Option(TableClassSummary),
    warm_throughput: option.Option(TableWarmThroughputDescription),
  )
}

pub fn replica_description_default() -> ReplicaDescription {
  ReplicaDescription(
    global_secondary_indexes: option.None,
    global_table_settings_replication_mode: option.None,
    kms_master_key_id: option.None,
    on_demand_throughput_override: option.None,
    provisioned_throughput_override: option.None,
    region_name: option.None,
    replica_arn: option.None,
    replica_inaccessible_date_time: option.None,
    replica_status: option.None,
    replica_status_description: option.None,
    replica_status_percent_progress: option.None,
    replica_table_class_summary: option.None,
    warm_throughput: option.None,
  )
}

pub fn encode_replica_description_struct(
  input: ReplicaDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.global_secondary_indexes {
    option.Some(v) -> [
      #(
        "GlobalSecondaryIndexes",
        fn(xs) {
          json.array(
            xs,
            encode_replica_global_secondary_index_description_struct,
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.global_table_settings_replication_mode {
    option.Some(v) -> [
      #(
        "GlobalTableSettingsReplicationMode",
        encode_global_table_settings_replication_mode_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.kms_master_key_id {
    option.Some(v) -> [#("KMSMasterKeyId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.on_demand_throughput_override {
    option.Some(v) -> [
      #(
        "OnDemandThroughputOverride",
        encode_on_demand_throughput_override_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_throughput_override {
    option.Some(v) -> [
      #(
        "ProvisionedThroughputOverride",
        encode_provisioned_throughput_override_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.region_name {
    option.Some(v) -> [#("RegionName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.replica_arn {
    option.Some(v) -> [#("ReplicaArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.replica_inaccessible_date_time {
    option.Some(v) -> [
      #("ReplicaInaccessibleDateTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.replica_status {
    option.Some(v) -> [
      #("ReplicaStatus", encode_replica_status_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.replica_status_description {
    option.Some(v) -> [#("ReplicaStatusDescription", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.replica_status_percent_progress {
    option.Some(v) -> [
      #("ReplicaStatusPercentProgress", json.string(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.replica_table_class_summary {
    option.Some(v) -> [
      #("ReplicaTableClassSummary", encode_table_class_summary_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.warm_throughput {
    option.Some(v) -> [
      #("WarmThroughput", encode_table_warm_throughput_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_replica_description_struct_top(
  input: ReplicaDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.global_secondary_indexes {
    option.Some(v) -> [
      #(
        "GlobalSecondaryIndexes",
        fn(xs) {
          json.array(
            xs,
            encode_replica_global_secondary_index_description_struct,
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.global_table_settings_replication_mode {
    option.Some(v) -> [
      #(
        "GlobalTableSettingsReplicationMode",
        encode_global_table_settings_replication_mode_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.kms_master_key_id {
    option.Some(v) -> [#("KMSMasterKeyId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.on_demand_throughput_override {
    option.Some(v) -> [
      #(
        "OnDemandThroughputOverride",
        encode_on_demand_throughput_override_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_throughput_override {
    option.Some(v) -> [
      #(
        "ProvisionedThroughputOverride",
        encode_provisioned_throughput_override_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.region_name {
    option.Some(v) -> [#("RegionName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.replica_arn {
    option.Some(v) -> [#("ReplicaArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.replica_inaccessible_date_time {
    option.Some(v) -> [
      #("ReplicaInaccessibleDateTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.replica_status {
    option.Some(v) -> [
      #("ReplicaStatus", encode_replica_status_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.replica_status_description {
    option.Some(v) -> [#("ReplicaStatusDescription", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.replica_status_percent_progress {
    option.Some(v) -> [
      #("ReplicaStatusPercentProgress", json.string(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.replica_table_class_summary {
    option.Some(v) -> [
      #("ReplicaTableClassSummary", encode_table_class_summary_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.warm_throughput {
    option.Some(v) -> [
      #("WarmThroughput", encode_table_warm_throughput_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_replica_description_struct() -> decode.Decoder(ReplicaDescription) {
  use <- decode.recursive
  use global_secondary_indexes <- decode.optional_field(
    "GlobalSecondaryIndexes",
    option.None,
    decode.optional(
      decode.list(decode_replica_global_secondary_index_description_struct()),
    ),
  )
  use global_table_settings_replication_mode <- decode.optional_field(
    "GlobalTableSettingsReplicationMode",
    option.None,
    decode.optional(decode_global_table_settings_replication_mode_enum()),
  )
  use kms_master_key_id <- decode.optional_field(
    "KMSMasterKeyId",
    option.None,
    decode.optional(decode.string),
  )
  use on_demand_throughput_override <- decode.optional_field(
    "OnDemandThroughputOverride",
    option.None,
    decode.optional(decode_on_demand_throughput_override_struct()),
  )
  use provisioned_throughput_override <- decode.optional_field(
    "ProvisionedThroughputOverride",
    option.None,
    decode.optional(decode_provisioned_throughput_override_struct()),
  )
  use region_name <- decode.optional_field(
    "RegionName",
    option.None,
    decode.optional(decode.string),
  )
  use replica_arn <- decode.optional_field(
    "ReplicaArn",
    option.None,
    decode.optional(decode.string),
  )
  use replica_inaccessible_date_time <- decode.optional_field(
    "ReplicaInaccessibleDateTime",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use replica_status <- decode.optional_field(
    "ReplicaStatus",
    option.None,
    decode.optional(decode_replica_status_enum()),
  )
  use replica_status_description <- decode.optional_field(
    "ReplicaStatusDescription",
    option.None,
    decode.optional(decode.string),
  )
  use replica_status_percent_progress <- decode.optional_field(
    "ReplicaStatusPercentProgress",
    option.None,
    decode.optional(decode.string),
  )
  use replica_table_class_summary <- decode.optional_field(
    "ReplicaTableClassSummary",
    option.None,
    decode.optional(decode_table_class_summary_struct()),
  )
  use warm_throughput <- decode.optional_field(
    "WarmThroughput",
    option.None,
    decode.optional(decode_table_warm_throughput_description_struct()),
  )
  decode.success(ReplicaDescription(
    global_secondary_indexes: global_secondary_indexes,
    global_table_settings_replication_mode: global_table_settings_replication_mode,
    kms_master_key_id: kms_master_key_id,
    on_demand_throughput_override: on_demand_throughput_override,
    provisioned_throughput_override: provisioned_throughput_override,
    region_name: region_name,
    replica_arn: replica_arn,
    replica_inaccessible_date_time: replica_inaccessible_date_time,
    replica_status: replica_status,
    replica_status_description: replica_status_description,
    replica_status_percent_progress: replica_status_percent_progress,
    replica_table_class_summary: replica_table_class_summary,
    warm_throughput: warm_throughput,
  ))
}

pub type ReplicaGlobalSecondaryIndexDescription {
  ReplicaGlobalSecondaryIndexDescription(
    index_name: option.Option(String),
    on_demand_throughput_override: option.Option(OnDemandThroughputOverride),
    provisioned_throughput_override: option.Option(
      ProvisionedThroughputOverride,
    ),
    warm_throughput: option.Option(
      GlobalSecondaryIndexWarmThroughputDescription,
    ),
  )
}

pub fn replica_global_secondary_index_description_default() -> ReplicaGlobalSecondaryIndexDescription {
  ReplicaGlobalSecondaryIndexDescription(
    index_name: option.None,
    on_demand_throughput_override: option.None,
    provisioned_throughput_override: option.None,
    warm_throughput: option.None,
  )
}

pub fn encode_replica_global_secondary_index_description_struct(
  input: ReplicaGlobalSecondaryIndexDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.on_demand_throughput_override {
    option.Some(v) -> [
      #(
        "OnDemandThroughputOverride",
        encode_on_demand_throughput_override_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_throughput_override {
    option.Some(v) -> [
      #(
        "ProvisionedThroughputOverride",
        encode_provisioned_throughput_override_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.warm_throughput {
    option.Some(v) -> [
      #(
        "WarmThroughput",
        encode_global_secondary_index_warm_throughput_description_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_replica_global_secondary_index_description_struct_top(
  input: ReplicaGlobalSecondaryIndexDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.on_demand_throughput_override {
    option.Some(v) -> [
      #(
        "OnDemandThroughputOverride",
        encode_on_demand_throughput_override_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_throughput_override {
    option.Some(v) -> [
      #(
        "ProvisionedThroughputOverride",
        encode_provisioned_throughput_override_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.warm_throughput {
    option.Some(v) -> [
      #(
        "WarmThroughput",
        encode_global_secondary_index_warm_throughput_description_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_replica_global_secondary_index_description_struct() -> decode.Decoder(
  ReplicaGlobalSecondaryIndexDescription,
) {
  use <- decode.recursive
  use index_name <- decode.optional_field(
    "IndexName",
    option.None,
    decode.optional(decode.string),
  )
  use on_demand_throughput_override <- decode.optional_field(
    "OnDemandThroughputOverride",
    option.None,
    decode.optional(decode_on_demand_throughput_override_struct()),
  )
  use provisioned_throughput_override <- decode.optional_field(
    "ProvisionedThroughputOverride",
    option.None,
    decode.optional(decode_provisioned_throughput_override_struct()),
  )
  use warm_throughput <- decode.optional_field(
    "WarmThroughput",
    option.None,
    decode.optional(
      decode_global_secondary_index_warm_throughput_description_struct(),
    ),
  )
  decode.success(ReplicaGlobalSecondaryIndexDescription(
    index_name: index_name,
    on_demand_throughput_override: on_demand_throughput_override,
    provisioned_throughput_override: provisioned_throughput_override,
    warm_throughput: warm_throughput,
  ))
}

pub type OnDemandThroughputOverride {
  OnDemandThroughputOverride(max_read_request_units: option.Option(Int))
}

pub fn on_demand_throughput_override_default() -> OnDemandThroughputOverride {
  OnDemandThroughputOverride(max_read_request_units: option.None)
}

pub fn encode_on_demand_throughput_override_struct(
  input: OnDemandThroughputOverride,
) -> json.Json {
  let pairs = []
  let pairs = case input.max_read_request_units {
    option.Some(v) -> [#("MaxReadRequestUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_on_demand_throughput_override_struct_top(
  input: OnDemandThroughputOverride,
) -> json.Json {
  let pairs = []
  let pairs = case input.max_read_request_units {
    option.Some(v) -> [#("MaxReadRequestUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_on_demand_throughput_override_struct() -> decode.Decoder(
  OnDemandThroughputOverride,
) {
  use <- decode.recursive
  use max_read_request_units <- decode.optional_field(
    "MaxReadRequestUnits",
    option.None,
    decode.optional(decode.int),
  )
  decode.success(OnDemandThroughputOverride(
    max_read_request_units: max_read_request_units,
  ))
}

pub type ProvisionedThroughputOverride {
  ProvisionedThroughputOverride(read_capacity_units: option.Option(Int))
}

pub fn provisioned_throughput_override_default() -> ProvisionedThroughputOverride {
  ProvisionedThroughputOverride(read_capacity_units: option.None)
}

pub fn encode_provisioned_throughput_override_struct(
  input: ProvisionedThroughputOverride,
) -> json.Json {
  let pairs = []
  let pairs = case input.read_capacity_units {
    option.Some(v) -> [#("ReadCapacityUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_provisioned_throughput_override_struct_top(
  input: ProvisionedThroughputOverride,
) -> json.Json {
  let pairs = []
  let pairs = case input.read_capacity_units {
    option.Some(v) -> [#("ReadCapacityUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_provisioned_throughput_override_struct() -> decode.Decoder(
  ProvisionedThroughputOverride,
) {
  use <- decode.recursive
  use read_capacity_units <- decode.optional_field(
    "ReadCapacityUnits",
    option.None,
    decode.optional(decode.int),
  )
  decode.success(ProvisionedThroughputOverride(
    read_capacity_units: read_capacity_units,
  ))
}

pub type GlobalSecondaryIndexWarmThroughputDescription {
  GlobalSecondaryIndexWarmThroughputDescription(
    read_units_per_second: option.Option(Int),
    status: option.Option(IndexStatus),
    write_units_per_second: option.Option(Int),
  )
}

pub fn global_secondary_index_warm_throughput_description_default() -> GlobalSecondaryIndexWarmThroughputDescription {
  GlobalSecondaryIndexWarmThroughputDescription(
    read_units_per_second: option.None,
    status: option.None,
    write_units_per_second: option.None,
  )
}

pub fn encode_global_secondary_index_warm_throughput_description_struct(
  input: GlobalSecondaryIndexWarmThroughputDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.read_units_per_second {
    option.Some(v) -> [#("ReadUnitsPerSecond", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.status {
    option.Some(v) -> [#("Status", encode_index_status_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.write_units_per_second {
    option.Some(v) -> [#("WriteUnitsPerSecond", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_global_secondary_index_warm_throughput_description_struct_top(
  input: GlobalSecondaryIndexWarmThroughputDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.read_units_per_second {
    option.Some(v) -> [#("ReadUnitsPerSecond", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.status {
    option.Some(v) -> [#("Status", encode_index_status_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.write_units_per_second {
    option.Some(v) -> [#("WriteUnitsPerSecond", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_global_secondary_index_warm_throughput_description_struct() -> decode.Decoder(
  GlobalSecondaryIndexWarmThroughputDescription,
) {
  use <- decode.recursive
  use read_units_per_second <- decode.optional_field(
    "ReadUnitsPerSecond",
    option.None,
    decode.optional(decode.int),
  )
  use status <- decode.optional_field(
    "Status",
    option.None,
    decode.optional(decode_index_status_enum()),
  )
  use write_units_per_second <- decode.optional_field(
    "WriteUnitsPerSecond",
    option.None,
    decode.optional(decode.int),
  )
  decode.success(GlobalSecondaryIndexWarmThroughputDescription(
    read_units_per_second: read_units_per_second,
    status: status,
    write_units_per_second: write_units_per_second,
  ))
}

pub type IndexStatus {
  IndexStatusActive
  IndexStatusCreating
  IndexStatusDeleting
  IndexStatusUpdating
}

pub fn encode_index_status_enum(v: IndexStatus) -> json.Json {
  case v {
    IndexStatusActive -> json.string("ACTIVE")
    IndexStatusCreating -> json.string("CREATING")
    IndexStatusDeleting -> json.string("DELETING")
    IndexStatusUpdating -> json.string("UPDATING")
  }
}

pub fn decode_index_status_enum() -> decode.Decoder(IndexStatus) {
  decode.then(decode.string, fn(s) {
    case s {
      "ACTIVE" -> decode.success(IndexStatusActive)
      "CREATING" -> decode.success(IndexStatusCreating)
      "DELETING" -> decode.success(IndexStatusDeleting)
      "UPDATING" -> decode.success(IndexStatusUpdating)
      _ -> decode.failure(IndexStatusActive, "unknown enum value")
    }
  })
}

pub type GlobalTableSettingsReplicationMode {
  GlobalTableSettingsReplicationModeDisabled
  GlobalTableSettingsReplicationModeEnabled
  GlobalTableSettingsReplicationModeEnabledWithOverrides
}

pub fn encode_global_table_settings_replication_mode_enum(
  v: GlobalTableSettingsReplicationMode,
) -> json.Json {
  case v {
    GlobalTableSettingsReplicationModeDisabled -> json.string("DISABLED")
    GlobalTableSettingsReplicationModeEnabled -> json.string("ENABLED")
    GlobalTableSettingsReplicationModeEnabledWithOverrides ->
      json.string("ENABLED_WITH_OVERRIDES")
  }
}

pub fn decode_global_table_settings_replication_mode_enum() -> decode.Decoder(
  GlobalTableSettingsReplicationMode,
) {
  decode.then(decode.string, fn(s) {
    case s {
      "DISABLED" -> decode.success(GlobalTableSettingsReplicationModeDisabled)
      "ENABLED" -> decode.success(GlobalTableSettingsReplicationModeEnabled)
      "ENABLED_WITH_OVERRIDES" ->
        decode.success(GlobalTableSettingsReplicationModeEnabledWithOverrides)
      _ ->
        decode.failure(
          GlobalTableSettingsReplicationModeDisabled,
          "unknown enum value",
        )
    }
  })
}

pub type ReplicaStatus {
  ReplicaStatusActive
  ReplicaStatusArchived
  ReplicaStatusArchiving
  ReplicaStatusCreating
  ReplicaStatusCreationFailed
  ReplicaStatusDeleting
  ReplicaStatusInaccessibleEncryptionCredentials
  ReplicaStatusRegionDisabled
  ReplicaStatusReplicationNotAuthorized
  ReplicaStatusUpdating
}

pub fn encode_replica_status_enum(v: ReplicaStatus) -> json.Json {
  case v {
    ReplicaStatusActive -> json.string("ACTIVE")
    ReplicaStatusArchived -> json.string("ARCHIVED")
    ReplicaStatusArchiving -> json.string("ARCHIVING")
    ReplicaStatusCreating -> json.string("CREATING")
    ReplicaStatusCreationFailed -> json.string("CREATION_FAILED")
    ReplicaStatusDeleting -> json.string("DELETING")
    ReplicaStatusInaccessibleEncryptionCredentials ->
      json.string("INACCESSIBLE_ENCRYPTION_CREDENTIALS")
    ReplicaStatusRegionDisabled -> json.string("REGION_DISABLED")
    ReplicaStatusReplicationNotAuthorized ->
      json.string("REPLICATION_NOT_AUTHORIZED")
    ReplicaStatusUpdating -> json.string("UPDATING")
  }
}

pub fn decode_replica_status_enum() -> decode.Decoder(ReplicaStatus) {
  decode.then(decode.string, fn(s) {
    case s {
      "ACTIVE" -> decode.success(ReplicaStatusActive)
      "ARCHIVED" -> decode.success(ReplicaStatusArchived)
      "ARCHIVING" -> decode.success(ReplicaStatusArchiving)
      "CREATING" -> decode.success(ReplicaStatusCreating)
      "CREATION_FAILED" -> decode.success(ReplicaStatusCreationFailed)
      "DELETING" -> decode.success(ReplicaStatusDeleting)
      "INACCESSIBLE_ENCRYPTION_CREDENTIALS" ->
        decode.success(ReplicaStatusInaccessibleEncryptionCredentials)
      "REGION_DISABLED" -> decode.success(ReplicaStatusRegionDisabled)
      "REPLICATION_NOT_AUTHORIZED" ->
        decode.success(ReplicaStatusReplicationNotAuthorized)
      "UPDATING" -> decode.success(ReplicaStatusUpdating)
      _ -> decode.failure(ReplicaStatusActive, "unknown enum value")
    }
  })
}

pub type TableClassSummary {
  TableClassSummary(
    last_update_date_time: option.Option(json_timestamp.Timestamp),
    table_class: option.Option(TableClass),
  )
}

pub fn table_class_summary_default() -> TableClassSummary {
  TableClassSummary(
    last_update_date_time: option.None,
    table_class: option.None,
  )
}

pub fn encode_table_class_summary_struct(
  input: TableClassSummary,
) -> json.Json {
  let pairs = []
  let pairs = case input.last_update_date_time {
    option.Some(v) -> [
      #("LastUpdateDateTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_class {
    option.Some(v) -> [#("TableClass", encode_table_class_enum(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_table_class_summary_struct_top(
  input: TableClassSummary,
) -> json.Json {
  let pairs = []
  let pairs = case input.last_update_date_time {
    option.Some(v) -> [
      #("LastUpdateDateTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_class {
    option.Some(v) -> [#("TableClass", encode_table_class_enum(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_table_class_summary_struct() -> decode.Decoder(TableClassSummary) {
  use <- decode.recursive
  use last_update_date_time <- decode.optional_field(
    "LastUpdateDateTime",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use table_class <- decode.optional_field(
    "TableClass",
    option.None,
    decode.optional(decode_table_class_enum()),
  )
  decode.success(TableClassSummary(
    last_update_date_time: last_update_date_time,
    table_class: table_class,
  ))
}

pub type TableClass {
  TableClassStandard
  TableClassStandardInfrequentAccess
}

pub fn encode_table_class_enum(v: TableClass) -> json.Json {
  case v {
    TableClassStandard -> json.string("STANDARD")
    TableClassStandardInfrequentAccess ->
      json.string("STANDARD_INFREQUENT_ACCESS")
  }
}

pub fn decode_table_class_enum() -> decode.Decoder(TableClass) {
  decode.then(decode.string, fn(s) {
    case s {
      "STANDARD" -> decode.success(TableClassStandard)
      "STANDARD_INFREQUENT_ACCESS" ->
        decode.success(TableClassStandardInfrequentAccess)
      _ -> decode.failure(TableClassStandard, "unknown enum value")
    }
  })
}

pub type TableWarmThroughputDescription {
  TableWarmThroughputDescription(
    read_units_per_second: option.Option(Int),
    status: option.Option(TableStatus),
    write_units_per_second: option.Option(Int),
  )
}

pub fn table_warm_throughput_description_default() -> TableWarmThroughputDescription {
  TableWarmThroughputDescription(
    read_units_per_second: option.None,
    status: option.None,
    write_units_per_second: option.None,
  )
}

pub fn encode_table_warm_throughput_description_struct(
  input: TableWarmThroughputDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.read_units_per_second {
    option.Some(v) -> [#("ReadUnitsPerSecond", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.status {
    option.Some(v) -> [#("Status", encode_table_status_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.write_units_per_second {
    option.Some(v) -> [#("WriteUnitsPerSecond", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_table_warm_throughput_description_struct_top(
  input: TableWarmThroughputDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.read_units_per_second {
    option.Some(v) -> [#("ReadUnitsPerSecond", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.status {
    option.Some(v) -> [#("Status", encode_table_status_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.write_units_per_second {
    option.Some(v) -> [#("WriteUnitsPerSecond", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_table_warm_throughput_description_struct() -> decode.Decoder(
  TableWarmThroughputDescription,
) {
  use <- decode.recursive
  use read_units_per_second <- decode.optional_field(
    "ReadUnitsPerSecond",
    option.None,
    decode.optional(decode.int),
  )
  use status <- decode.optional_field(
    "Status",
    option.None,
    decode.optional(decode_table_status_enum()),
  )
  use write_units_per_second <- decode.optional_field(
    "WriteUnitsPerSecond",
    option.None,
    decode.optional(decode.int),
  )
  decode.success(TableWarmThroughputDescription(
    read_units_per_second: read_units_per_second,
    status: status,
    write_units_per_second: write_units_per_second,
  ))
}

pub type TableStatus {
  TableStatusActive
  TableStatusArchived
  TableStatusArchiving
  TableStatusCreating
  TableStatusDeleting
  TableStatusInaccessibleEncryptionCredentials
  TableStatusReplicationNotAuthorized
  TableStatusUpdating
}

pub fn encode_table_status_enum(v: TableStatus) -> json.Json {
  case v {
    TableStatusActive -> json.string("ACTIVE")
    TableStatusArchived -> json.string("ARCHIVED")
    TableStatusArchiving -> json.string("ARCHIVING")
    TableStatusCreating -> json.string("CREATING")
    TableStatusDeleting -> json.string("DELETING")
    TableStatusInaccessibleEncryptionCredentials ->
      json.string("INACCESSIBLE_ENCRYPTION_CREDENTIALS")
    TableStatusReplicationNotAuthorized ->
      json.string("REPLICATION_NOT_AUTHORIZED")
    TableStatusUpdating -> json.string("UPDATING")
  }
}

pub fn decode_table_status_enum() -> decode.Decoder(TableStatus) {
  decode.then(decode.string, fn(s) {
    case s {
      "ACTIVE" -> decode.success(TableStatusActive)
      "ARCHIVED" -> decode.success(TableStatusArchived)
      "ARCHIVING" -> decode.success(TableStatusArchiving)
      "CREATING" -> decode.success(TableStatusCreating)
      "DELETING" -> decode.success(TableStatusDeleting)
      "INACCESSIBLE_ENCRYPTION_CREDENTIALS" ->
        decode.success(TableStatusInaccessibleEncryptionCredentials)
      "REPLICATION_NOT_AUTHORIZED" ->
        decode.success(TableStatusReplicationNotAuthorized)
      "UPDATING" -> decode.success(TableStatusUpdating)
      _ -> decode.failure(TableStatusActive, "unknown enum value")
    }
  })
}

pub type GlobalTableAlreadyExistsException {
  GlobalTableAlreadyExistsException(message: option.Option(String))
}

pub fn global_table_already_exists_exception_default() -> GlobalTableAlreadyExistsException {
  GlobalTableAlreadyExistsException(message: option.None)
}

pub fn encode_global_table_already_exists_exception_struct(
  input: GlobalTableAlreadyExistsException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_global_table_already_exists_exception_struct_top(
  input: GlobalTableAlreadyExistsException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_global_table_already_exists_exception_struct() -> decode.Decoder(
  GlobalTableAlreadyExistsException,
) {
  use <- decode.recursive
  use message <- decode.optional_field(
    "message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GlobalTableAlreadyExistsException(message: message))
}

pub type CreateTableInput {
  CreateTableInput(
    attribute_definitions: option.Option(List(AttributeDefinition)),
    billing_mode: option.Option(BillingMode),
    deletion_protection_enabled: option.Option(Bool),
    global_secondary_indexes: option.Option(List(GlobalSecondaryIndex)),
    global_table_settings_replication_mode: option.Option(
      GlobalTableSettingsReplicationMode,
    ),
    global_table_source_arn: option.Option(String),
    key_schema: option.Option(List(KeySchemaElement)),
    local_secondary_indexes: option.Option(List(LocalSecondaryIndex)),
    on_demand_throughput: option.Option(OnDemandThroughput),
    provisioned_throughput: option.Option(ProvisionedThroughput),
    resource_policy: option.Option(String),
    sse_specification: option.Option(SSESpecification),
    stream_specification: option.Option(StreamSpecification),
    table_class: option.Option(TableClass),
    table_name: option.Option(String),
    tags: option.Option(List(Tag)),
    warm_throughput: option.Option(WarmThroughput),
  )
}

pub fn create_table_input_default() -> CreateTableInput {
  CreateTableInput(
    attribute_definitions: option.None,
    billing_mode: option.None,
    deletion_protection_enabled: option.None,
    global_secondary_indexes: option.None,
    global_table_settings_replication_mode: option.None,
    global_table_source_arn: option.None,
    key_schema: option.None,
    local_secondary_indexes: option.None,
    on_demand_throughput: option.None,
    provisioned_throughput: option.None,
    resource_policy: option.None,
    sse_specification: option.None,
    stream_specification: option.None,
    table_class: option.None,
    table_name: option.None,
    tags: option.None,
    warm_throughput: option.None,
  )
}

pub fn encode_create_table_input_struct(input: CreateTableInput) -> json.Json {
  let pairs = []
  let pairs = case input.attribute_definitions {
    option.Some(v) -> [
      #(
        "AttributeDefinitions",
        fn(xs) { json.array(xs, encode_attribute_definition_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.billing_mode {
    option.Some(v) -> [#("BillingMode", encode_billing_mode_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.deletion_protection_enabled {
    option.Some(v) -> [#("DeletionProtectionEnabled", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.global_secondary_indexes {
    option.Some(v) -> [
      #(
        "GlobalSecondaryIndexes",
        fn(xs) { json.array(xs, encode_global_secondary_index_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.global_table_settings_replication_mode {
    option.Some(v) -> [
      #(
        "GlobalTableSettingsReplicationMode",
        encode_global_table_settings_replication_mode_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.global_table_source_arn {
    option.Some(v) -> [#("GlobalTableSourceArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.key_schema {
    option.Some(v) -> [
      #(
        "KeySchema",
        fn(xs) { json.array(xs, encode_key_schema_element_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.local_secondary_indexes {
    option.Some(v) -> [
      #(
        "LocalSecondaryIndexes",
        fn(xs) { json.array(xs, encode_local_secondary_index_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.on_demand_throughput {
    option.Some(v) -> [
      #("OnDemandThroughput", encode_on_demand_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_throughput {
    option.Some(v) -> [
      #("ProvisionedThroughput", encode_provisioned_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.resource_policy {
    option.Some(v) -> [#("ResourcePolicy", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.sse_specification {
    option.Some(v) -> [
      #("SSESpecification", encode_sse_specification_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.stream_specification {
    option.Some(v) -> [
      #("StreamSpecification", encode_stream_specification_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_class {
    option.Some(v) -> [#("TableClass", encode_table_class_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.tags {
    option.Some(v) -> [
      #("Tags", fn(xs) { json.array(xs, encode_tag_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.warm_throughput {
    option.Some(v) -> [
      #("WarmThroughput", encode_warm_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_create_table_input_struct_top(
  input: CreateTableInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.attribute_definitions {
    option.Some(v) -> [
      #(
        "AttributeDefinitions",
        fn(xs) { json.array(xs, encode_attribute_definition_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.billing_mode {
    option.Some(v) -> [#("BillingMode", encode_billing_mode_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.deletion_protection_enabled {
    option.Some(v) -> [#("DeletionProtectionEnabled", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.global_secondary_indexes {
    option.Some(v) -> [
      #(
        "GlobalSecondaryIndexes",
        fn(xs) { json.array(xs, encode_global_secondary_index_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.global_table_settings_replication_mode {
    option.Some(v) -> [
      #(
        "GlobalTableSettingsReplicationMode",
        encode_global_table_settings_replication_mode_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.global_table_source_arn {
    option.Some(v) -> [#("GlobalTableSourceArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.key_schema {
    option.Some(v) -> [
      #(
        "KeySchema",
        fn(xs) { json.array(xs, encode_key_schema_element_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.local_secondary_indexes {
    option.Some(v) -> [
      #(
        "LocalSecondaryIndexes",
        fn(xs) { json.array(xs, encode_local_secondary_index_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.on_demand_throughput {
    option.Some(v) -> [
      #("OnDemandThroughput", encode_on_demand_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_throughput {
    option.Some(v) -> [
      #("ProvisionedThroughput", encode_provisioned_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.resource_policy {
    option.Some(v) -> [#("ResourcePolicy", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.sse_specification {
    option.Some(v) -> [
      #("SSESpecification", encode_sse_specification_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.stream_specification {
    option.Some(v) -> [
      #("StreamSpecification", encode_stream_specification_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_class {
    option.Some(v) -> [#("TableClass", encode_table_class_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.tags {
    option.Some(v) -> [
      #("Tags", fn(xs) { json.array(xs, encode_tag_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.warm_throughput {
    option.Some(v) -> [
      #("WarmThroughput", encode_warm_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_create_table_input_struct() -> decode.Decoder(CreateTableInput) {
  use <- decode.recursive
  use attribute_definitions <- decode.optional_field(
    "AttributeDefinitions",
    option.None,
    decode.optional(decode.list(decode_attribute_definition_struct())),
  )
  use billing_mode <- decode.optional_field(
    "BillingMode",
    option.None,
    decode.optional(decode_billing_mode_enum()),
  )
  use deletion_protection_enabled <- decode.optional_field(
    "DeletionProtectionEnabled",
    option.None,
    decode.optional(decode.bool),
  )
  use global_secondary_indexes <- decode.optional_field(
    "GlobalSecondaryIndexes",
    option.None,
    decode.optional(decode.list(decode_global_secondary_index_struct())),
  )
  use global_table_settings_replication_mode <- decode.optional_field(
    "GlobalTableSettingsReplicationMode",
    option.None,
    decode.optional(decode_global_table_settings_replication_mode_enum()),
  )
  use global_table_source_arn <- decode.optional_field(
    "GlobalTableSourceArn",
    option.None,
    decode.optional(decode.string),
  )
  use key_schema <- decode.optional_field(
    "KeySchema",
    option.None,
    decode.optional(decode.list(decode_key_schema_element_struct())),
  )
  use local_secondary_indexes <- decode.optional_field(
    "LocalSecondaryIndexes",
    option.None,
    decode.optional(decode.list(decode_local_secondary_index_struct())),
  )
  use on_demand_throughput <- decode.optional_field(
    "OnDemandThroughput",
    option.None,
    decode.optional(decode_on_demand_throughput_struct()),
  )
  use provisioned_throughput <- decode.optional_field(
    "ProvisionedThroughput",
    option.None,
    decode.optional(decode_provisioned_throughput_struct()),
  )
  use resource_policy <- decode.optional_field(
    "ResourcePolicy",
    option.None,
    decode.optional(decode.string),
  )
  use sse_specification <- decode.optional_field(
    "SSESpecification",
    option.None,
    decode.optional(decode_sse_specification_struct()),
  )
  use stream_specification <- decode.optional_field(
    "StreamSpecification",
    option.None,
    decode.optional(decode_stream_specification_struct()),
  )
  use table_class <- decode.optional_field(
    "TableClass",
    option.None,
    decode.optional(decode_table_class_enum()),
  )
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  use tags <- decode.optional_field(
    "Tags",
    option.None,
    decode.optional(decode.list(decode_tag_struct())),
  )
  use warm_throughput <- decode.optional_field(
    "WarmThroughput",
    option.None,
    decode.optional(decode_warm_throughput_struct()),
  )
  decode.success(CreateTableInput(
    attribute_definitions: attribute_definitions,
    billing_mode: billing_mode,
    deletion_protection_enabled: deletion_protection_enabled,
    global_secondary_indexes: global_secondary_indexes,
    global_table_settings_replication_mode: global_table_settings_replication_mode,
    global_table_source_arn: global_table_source_arn,
    key_schema: key_schema,
    local_secondary_indexes: local_secondary_indexes,
    on_demand_throughput: on_demand_throughput,
    provisioned_throughput: provisioned_throughput,
    resource_policy: resource_policy,
    sse_specification: sse_specification,
    stream_specification: stream_specification,
    table_class: table_class,
    table_name: table_name,
    tags: tags,
    warm_throughput: warm_throughput,
  ))
}

pub type AttributeDefinition {
  AttributeDefinition(
    attribute_name: option.Option(String),
    attribute_type: option.Option(ScalarAttributeType),
  )
}

pub fn attribute_definition_default() -> AttributeDefinition {
  AttributeDefinition(attribute_name: option.None, attribute_type: option.None)
}

pub fn encode_attribute_definition_struct(
  input: AttributeDefinition,
) -> json.Json {
  let pairs = []
  let pairs = case input.attribute_name {
    option.Some(v) -> [#("AttributeName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.attribute_type {
    option.Some(v) -> [
      #("AttributeType", encode_scalar_attribute_type_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_attribute_definition_struct_top(
  input: AttributeDefinition,
) -> json.Json {
  let pairs = []
  let pairs = case input.attribute_name {
    option.Some(v) -> [#("AttributeName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.attribute_type {
    option.Some(v) -> [
      #("AttributeType", encode_scalar_attribute_type_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_attribute_definition_struct() -> decode.Decoder(
  AttributeDefinition,
) {
  use <- decode.recursive
  use attribute_name <- decode.optional_field(
    "AttributeName",
    option.None,
    decode.optional(decode.string),
  )
  use attribute_type <- decode.optional_field(
    "AttributeType",
    option.None,
    decode.optional(decode_scalar_attribute_type_enum()),
  )
  decode.success(AttributeDefinition(
    attribute_name: attribute_name,
    attribute_type: attribute_type,
  ))
}

pub type ScalarAttributeType {
  ScalarAttributeTypeB
  ScalarAttributeTypeN
  ScalarAttributeTypeS
}

pub fn encode_scalar_attribute_type_enum(v: ScalarAttributeType) -> json.Json {
  case v {
    ScalarAttributeTypeB -> json.string("B")
    ScalarAttributeTypeN -> json.string("N")
    ScalarAttributeTypeS -> json.string("S")
  }
}

pub fn decode_scalar_attribute_type_enum() -> decode.Decoder(
  ScalarAttributeType,
) {
  decode.then(decode.string, fn(s) {
    case s {
      "B" -> decode.success(ScalarAttributeTypeB)
      "N" -> decode.success(ScalarAttributeTypeN)
      "S" -> decode.success(ScalarAttributeTypeS)
      _ -> decode.failure(ScalarAttributeTypeB, "unknown enum value")
    }
  })
}

pub type BillingMode {
  BillingModePayPerRequest
  BillingModeProvisioned
}

pub fn encode_billing_mode_enum(v: BillingMode) -> json.Json {
  case v {
    BillingModePayPerRequest -> json.string("PAY_PER_REQUEST")
    BillingModeProvisioned -> json.string("PROVISIONED")
  }
}

pub fn decode_billing_mode_enum() -> decode.Decoder(BillingMode) {
  decode.then(decode.string, fn(s) {
    case s {
      "PAY_PER_REQUEST" -> decode.success(BillingModePayPerRequest)
      "PROVISIONED" -> decode.success(BillingModeProvisioned)
      _ -> decode.failure(BillingModePayPerRequest, "unknown enum value")
    }
  })
}

pub type GlobalSecondaryIndex {
  GlobalSecondaryIndex(
    index_name: option.Option(String),
    key_schema: option.Option(List(KeySchemaElement)),
    on_demand_throughput: option.Option(OnDemandThroughput),
    projection: option.Option(Projection),
    provisioned_throughput: option.Option(ProvisionedThroughput),
    warm_throughput: option.Option(WarmThroughput),
  )
}

pub fn global_secondary_index_default() -> GlobalSecondaryIndex {
  GlobalSecondaryIndex(
    index_name: option.None,
    key_schema: option.None,
    on_demand_throughput: option.None,
    projection: option.None,
    provisioned_throughput: option.None,
    warm_throughput: option.None,
  )
}

pub fn encode_global_secondary_index_struct(
  input: GlobalSecondaryIndex,
) -> json.Json {
  let pairs = []
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.key_schema {
    option.Some(v) -> [
      #(
        "KeySchema",
        fn(xs) { json.array(xs, encode_key_schema_element_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.on_demand_throughput {
    option.Some(v) -> [
      #("OnDemandThroughput", encode_on_demand_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.projection {
    option.Some(v) -> [#("Projection", encode_projection_struct(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.provisioned_throughput {
    option.Some(v) -> [
      #("ProvisionedThroughput", encode_provisioned_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.warm_throughput {
    option.Some(v) -> [
      #("WarmThroughput", encode_warm_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_global_secondary_index_struct_top(
  input: GlobalSecondaryIndex,
) -> json.Json {
  let pairs = []
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.key_schema {
    option.Some(v) -> [
      #(
        "KeySchema",
        fn(xs) { json.array(xs, encode_key_schema_element_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.on_demand_throughput {
    option.Some(v) -> [
      #("OnDemandThroughput", encode_on_demand_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.projection {
    option.Some(v) -> [#("Projection", encode_projection_struct(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.provisioned_throughput {
    option.Some(v) -> [
      #("ProvisionedThroughput", encode_provisioned_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.warm_throughput {
    option.Some(v) -> [
      #("WarmThroughput", encode_warm_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_global_secondary_index_struct() -> decode.Decoder(
  GlobalSecondaryIndex,
) {
  use <- decode.recursive
  use index_name <- decode.optional_field(
    "IndexName",
    option.None,
    decode.optional(decode.string),
  )
  use key_schema <- decode.optional_field(
    "KeySchema",
    option.None,
    decode.optional(decode.list(decode_key_schema_element_struct())),
  )
  use on_demand_throughput <- decode.optional_field(
    "OnDemandThroughput",
    option.None,
    decode.optional(decode_on_demand_throughput_struct()),
  )
  use projection <- decode.optional_field(
    "Projection",
    option.None,
    decode.optional(decode_projection_struct()),
  )
  use provisioned_throughput <- decode.optional_field(
    "ProvisionedThroughput",
    option.None,
    decode.optional(decode_provisioned_throughput_struct()),
  )
  use warm_throughput <- decode.optional_field(
    "WarmThroughput",
    option.None,
    decode.optional(decode_warm_throughput_struct()),
  )
  decode.success(GlobalSecondaryIndex(
    index_name: index_name,
    key_schema: key_schema,
    on_demand_throughput: on_demand_throughput,
    projection: projection,
    provisioned_throughput: provisioned_throughput,
    warm_throughput: warm_throughput,
  ))
}

pub type KeySchemaElement {
  KeySchemaElement(
    attribute_name: option.Option(String),
    key_type: option.Option(KeyType),
  )
}

pub fn key_schema_element_default() -> KeySchemaElement {
  KeySchemaElement(attribute_name: option.None, key_type: option.None)
}

pub fn encode_key_schema_element_struct(input: KeySchemaElement) -> json.Json {
  let pairs = []
  let pairs = case input.attribute_name {
    option.Some(v) -> [#("AttributeName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.key_type {
    option.Some(v) -> [#("KeyType", encode_key_type_enum(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_key_schema_element_struct_top(
  input: KeySchemaElement,
) -> json.Json {
  let pairs = []
  let pairs = case input.attribute_name {
    option.Some(v) -> [#("AttributeName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.key_type {
    option.Some(v) -> [#("KeyType", encode_key_type_enum(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_key_schema_element_struct() -> decode.Decoder(KeySchemaElement) {
  use <- decode.recursive
  use attribute_name <- decode.optional_field(
    "AttributeName",
    option.None,
    decode.optional(decode.string),
  )
  use key_type <- decode.optional_field(
    "KeyType",
    option.None,
    decode.optional(decode_key_type_enum()),
  )
  decode.success(KeySchemaElement(
    attribute_name: attribute_name,
    key_type: key_type,
  ))
}

pub type KeyType {
  KeyTypeHash
  KeyTypeRange
}

pub fn encode_key_type_enum(v: KeyType) -> json.Json {
  case v {
    KeyTypeHash -> json.string("HASH")
    KeyTypeRange -> json.string("RANGE")
  }
}

pub fn decode_key_type_enum() -> decode.Decoder(KeyType) {
  decode.then(decode.string, fn(s) {
    case s {
      "HASH" -> decode.success(KeyTypeHash)
      "RANGE" -> decode.success(KeyTypeRange)
      _ -> decode.failure(KeyTypeHash, "unknown enum value")
    }
  })
}

pub type OnDemandThroughput {
  OnDemandThroughput(
    max_read_request_units: option.Option(Int),
    max_write_request_units: option.Option(Int),
  )
}

pub fn on_demand_throughput_default() -> OnDemandThroughput {
  OnDemandThroughput(
    max_read_request_units: option.None,
    max_write_request_units: option.None,
  )
}

pub fn encode_on_demand_throughput_struct(
  input: OnDemandThroughput,
) -> json.Json {
  let pairs = []
  let pairs = case input.max_read_request_units {
    option.Some(v) -> [#("MaxReadRequestUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.max_write_request_units {
    option.Some(v) -> [#("MaxWriteRequestUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_on_demand_throughput_struct_top(
  input: OnDemandThroughput,
) -> json.Json {
  let pairs = []
  let pairs = case input.max_read_request_units {
    option.Some(v) -> [#("MaxReadRequestUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.max_write_request_units {
    option.Some(v) -> [#("MaxWriteRequestUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_on_demand_throughput_struct() -> decode.Decoder(
  OnDemandThroughput,
) {
  use <- decode.recursive
  use max_read_request_units <- decode.optional_field(
    "MaxReadRequestUnits",
    option.None,
    decode.optional(decode.int),
  )
  use max_write_request_units <- decode.optional_field(
    "MaxWriteRequestUnits",
    option.None,
    decode.optional(decode.int),
  )
  decode.success(OnDemandThroughput(
    max_read_request_units: max_read_request_units,
    max_write_request_units: max_write_request_units,
  ))
}

pub type Projection {
  Projection(
    non_key_attributes: option.Option(List(String)),
    projection_type: option.Option(ProjectionType),
  )
}

pub fn projection_default() -> Projection {
  Projection(non_key_attributes: option.None, projection_type: option.None)
}

pub fn encode_projection_struct(input: Projection) -> json.Json {
  let pairs = []
  let pairs = case input.non_key_attributes {
    option.Some(v) -> [
      #("NonKeyAttributes", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.projection_type {
    option.Some(v) -> [
      #("ProjectionType", encode_projection_type_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_projection_struct_top(input: Projection) -> json.Json {
  let pairs = []
  let pairs = case input.non_key_attributes {
    option.Some(v) -> [
      #("NonKeyAttributes", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.projection_type {
    option.Some(v) -> [
      #("ProjectionType", encode_projection_type_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_projection_struct() -> decode.Decoder(Projection) {
  use <- decode.recursive
  use non_key_attributes <- decode.optional_field(
    "NonKeyAttributes",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  use projection_type <- decode.optional_field(
    "ProjectionType",
    option.None,
    decode.optional(decode_projection_type_enum()),
  )
  decode.success(Projection(
    non_key_attributes: non_key_attributes,
    projection_type: projection_type,
  ))
}

pub type ProjectionType {
  ProjectionTypeAll
  ProjectionTypeInclude
  ProjectionTypeKeysOnly
}

pub fn encode_projection_type_enum(v: ProjectionType) -> json.Json {
  case v {
    ProjectionTypeAll -> json.string("ALL")
    ProjectionTypeInclude -> json.string("INCLUDE")
    ProjectionTypeKeysOnly -> json.string("KEYS_ONLY")
  }
}

pub fn decode_projection_type_enum() -> decode.Decoder(ProjectionType) {
  decode.then(decode.string, fn(s) {
    case s {
      "ALL" -> decode.success(ProjectionTypeAll)
      "INCLUDE" -> decode.success(ProjectionTypeInclude)
      "KEYS_ONLY" -> decode.success(ProjectionTypeKeysOnly)
      _ -> decode.failure(ProjectionTypeAll, "unknown enum value")
    }
  })
}

pub type ProvisionedThroughput {
  ProvisionedThroughput(
    read_capacity_units: option.Option(Int),
    write_capacity_units: option.Option(Int),
  )
}

pub fn provisioned_throughput_default() -> ProvisionedThroughput {
  ProvisionedThroughput(
    read_capacity_units: option.None,
    write_capacity_units: option.None,
  )
}

pub fn encode_provisioned_throughput_struct(
  input: ProvisionedThroughput,
) -> json.Json {
  let pairs = []
  let pairs = case input.read_capacity_units {
    option.Some(v) -> [#("ReadCapacityUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.write_capacity_units {
    option.Some(v) -> [#("WriteCapacityUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_provisioned_throughput_struct_top(
  input: ProvisionedThroughput,
) -> json.Json {
  let pairs = []
  let pairs = case input.read_capacity_units {
    option.Some(v) -> [#("ReadCapacityUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.write_capacity_units {
    option.Some(v) -> [#("WriteCapacityUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_provisioned_throughput_struct() -> decode.Decoder(
  ProvisionedThroughput,
) {
  use <- decode.recursive
  use read_capacity_units <- decode.optional_field(
    "ReadCapacityUnits",
    option.None,
    decode.optional(decode.int),
  )
  use write_capacity_units <- decode.optional_field(
    "WriteCapacityUnits",
    option.None,
    decode.optional(decode.int),
  )
  decode.success(ProvisionedThroughput(
    read_capacity_units: read_capacity_units,
    write_capacity_units: write_capacity_units,
  ))
}

pub type WarmThroughput {
  WarmThroughput(
    read_units_per_second: option.Option(Int),
    write_units_per_second: option.Option(Int),
  )
}

pub fn warm_throughput_default() -> WarmThroughput {
  WarmThroughput(
    read_units_per_second: option.None,
    write_units_per_second: option.None,
  )
}

pub fn encode_warm_throughput_struct(input: WarmThroughput) -> json.Json {
  let pairs = []
  let pairs = case input.read_units_per_second {
    option.Some(v) -> [#("ReadUnitsPerSecond", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.write_units_per_second {
    option.Some(v) -> [#("WriteUnitsPerSecond", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_warm_throughput_struct_top(input: WarmThroughput) -> json.Json {
  let pairs = []
  let pairs = case input.read_units_per_second {
    option.Some(v) -> [#("ReadUnitsPerSecond", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.write_units_per_second {
    option.Some(v) -> [#("WriteUnitsPerSecond", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_warm_throughput_struct() -> decode.Decoder(WarmThroughput) {
  use <- decode.recursive
  use read_units_per_second <- decode.optional_field(
    "ReadUnitsPerSecond",
    option.None,
    decode.optional(decode.int),
  )
  use write_units_per_second <- decode.optional_field(
    "WriteUnitsPerSecond",
    option.None,
    decode.optional(decode.int),
  )
  decode.success(WarmThroughput(
    read_units_per_second: read_units_per_second,
    write_units_per_second: write_units_per_second,
  ))
}

pub type LocalSecondaryIndex {
  LocalSecondaryIndex(
    index_name: option.Option(String),
    key_schema: option.Option(List(KeySchemaElement)),
    projection: option.Option(Projection),
  )
}

pub fn local_secondary_index_default() -> LocalSecondaryIndex {
  LocalSecondaryIndex(
    index_name: option.None,
    key_schema: option.None,
    projection: option.None,
  )
}

pub fn encode_local_secondary_index_struct(
  input: LocalSecondaryIndex,
) -> json.Json {
  let pairs = []
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.key_schema {
    option.Some(v) -> [
      #(
        "KeySchema",
        fn(xs) { json.array(xs, encode_key_schema_element_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.projection {
    option.Some(v) -> [#("Projection", encode_projection_struct(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_local_secondary_index_struct_top(
  input: LocalSecondaryIndex,
) -> json.Json {
  let pairs = []
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.key_schema {
    option.Some(v) -> [
      #(
        "KeySchema",
        fn(xs) { json.array(xs, encode_key_schema_element_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.projection {
    option.Some(v) -> [#("Projection", encode_projection_struct(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_local_secondary_index_struct() -> decode.Decoder(
  LocalSecondaryIndex,
) {
  use <- decode.recursive
  use index_name <- decode.optional_field(
    "IndexName",
    option.None,
    decode.optional(decode.string),
  )
  use key_schema <- decode.optional_field(
    "KeySchema",
    option.None,
    decode.optional(decode.list(decode_key_schema_element_struct())),
  )
  use projection <- decode.optional_field(
    "Projection",
    option.None,
    decode.optional(decode_projection_struct()),
  )
  decode.success(LocalSecondaryIndex(
    index_name: index_name,
    key_schema: key_schema,
    projection: projection,
  ))
}

pub type SSESpecification {
  SSESpecification(
    enabled: option.Option(Bool),
    kms_master_key_id: option.Option(String),
    sse_type: option.Option(SSEType),
  )
}

pub fn sse_specification_default() -> SSESpecification {
  SSESpecification(
    enabled: option.None,
    kms_master_key_id: option.None,
    sse_type: option.None,
  )
}

pub fn encode_sse_specification_struct(input: SSESpecification) -> json.Json {
  let pairs = []
  let pairs = case input.enabled {
    option.Some(v) -> [#("Enabled", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.kms_master_key_id {
    option.Some(v) -> [#("KMSMasterKeyId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.sse_type {
    option.Some(v) -> [#("SSEType", encode_sse_type_enum(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_sse_specification_struct_top(
  input: SSESpecification,
) -> json.Json {
  let pairs = []
  let pairs = case input.enabled {
    option.Some(v) -> [#("Enabled", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.kms_master_key_id {
    option.Some(v) -> [#("KMSMasterKeyId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.sse_type {
    option.Some(v) -> [#("SSEType", encode_sse_type_enum(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_sse_specification_struct() -> decode.Decoder(SSESpecification) {
  use <- decode.recursive
  use enabled <- decode.optional_field(
    "Enabled",
    option.None,
    decode.optional(decode.bool),
  )
  use kms_master_key_id <- decode.optional_field(
    "KMSMasterKeyId",
    option.None,
    decode.optional(decode.string),
  )
  use sse_type <- decode.optional_field(
    "SSEType",
    option.None,
    decode.optional(decode_sse_type_enum()),
  )
  decode.success(SSESpecification(
    enabled: enabled,
    kms_master_key_id: kms_master_key_id,
    sse_type: sse_type,
  ))
}

pub type SSEType {
  SSETypeAes256
  SSETypeKms
}

pub fn encode_sse_type_enum(v: SSEType) -> json.Json {
  case v {
    SSETypeAes256 -> json.string("AES256")
    SSETypeKms -> json.string("KMS")
  }
}

pub fn decode_sse_type_enum() -> decode.Decoder(SSEType) {
  decode.then(decode.string, fn(s) {
    case s {
      "AES256" -> decode.success(SSETypeAes256)
      "KMS" -> decode.success(SSETypeKms)
      _ -> decode.failure(SSETypeAes256, "unknown enum value")
    }
  })
}

pub type StreamSpecification {
  StreamSpecification(
    stream_enabled: option.Option(Bool),
    stream_view_type: option.Option(StreamViewType),
  )
}

pub fn stream_specification_default() -> StreamSpecification {
  StreamSpecification(
    stream_enabled: option.None,
    stream_view_type: option.None,
  )
}

pub fn encode_stream_specification_struct(
  input: StreamSpecification,
) -> json.Json {
  let pairs = []
  let pairs = case input.stream_enabled {
    option.Some(v) -> [#("StreamEnabled", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.stream_view_type {
    option.Some(v) -> [
      #("StreamViewType", encode_stream_view_type_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_stream_specification_struct_top(
  input: StreamSpecification,
) -> json.Json {
  let pairs = []
  let pairs = case input.stream_enabled {
    option.Some(v) -> [#("StreamEnabled", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.stream_view_type {
    option.Some(v) -> [
      #("StreamViewType", encode_stream_view_type_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_stream_specification_struct() -> decode.Decoder(
  StreamSpecification,
) {
  use <- decode.recursive
  use stream_enabled <- decode.optional_field(
    "StreamEnabled",
    option.None,
    decode.optional(decode.bool),
  )
  use stream_view_type <- decode.optional_field(
    "StreamViewType",
    option.None,
    decode.optional(decode_stream_view_type_enum()),
  )
  decode.success(StreamSpecification(
    stream_enabled: stream_enabled,
    stream_view_type: stream_view_type,
  ))
}

pub type StreamViewType {
  StreamViewTypeKeysOnly
  StreamViewTypeNewAndOldImages
  StreamViewTypeNewImage
  StreamViewTypeOldImage
}

pub fn encode_stream_view_type_enum(v: StreamViewType) -> json.Json {
  case v {
    StreamViewTypeKeysOnly -> json.string("KEYS_ONLY")
    StreamViewTypeNewAndOldImages -> json.string("NEW_AND_OLD_IMAGES")
    StreamViewTypeNewImage -> json.string("NEW_IMAGE")
    StreamViewTypeOldImage -> json.string("OLD_IMAGE")
  }
}

pub fn decode_stream_view_type_enum() -> decode.Decoder(StreamViewType) {
  decode.then(decode.string, fn(s) {
    case s {
      "KEYS_ONLY" -> decode.success(StreamViewTypeKeysOnly)
      "NEW_AND_OLD_IMAGES" -> decode.success(StreamViewTypeNewAndOldImages)
      "NEW_IMAGE" -> decode.success(StreamViewTypeNewImage)
      "OLD_IMAGE" -> decode.success(StreamViewTypeOldImage)
      _ -> decode.failure(StreamViewTypeKeysOnly, "unknown enum value")
    }
  })
}

pub type Tag {
  Tag(key: option.Option(String), value: option.Option(String))
}

pub fn tag_default() -> Tag {
  Tag(key: option.None, value: option.None)
}

pub fn encode_tag_struct(input: Tag) -> json.Json {
  let pairs = []
  let pairs = case input.key {
    option.Some(v) -> [#("Key", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.value {
    option.Some(v) -> [#("Value", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_tag_struct_top(input: Tag) -> json.Json {
  let pairs = []
  let pairs = case input.key {
    option.Some(v) -> [#("Key", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.value {
    option.Some(v) -> [#("Value", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_tag_struct() -> decode.Decoder(Tag) {
  use <- decode.recursive
  use key <- decode.optional_field(
    "Key",
    option.None,
    decode.optional(decode.string),
  )
  use value <- decode.optional_field(
    "Value",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(Tag(key: key, value: value))
}

pub type CreateTableOutput {
  CreateTableOutput(table_description: option.Option(TableDescription))
}

pub fn create_table_output_default() -> CreateTableOutput {
  CreateTableOutput(table_description: option.None)
}

pub fn encode_create_table_output_struct(
  input: CreateTableOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.table_description {
    option.Some(v) -> [
      #("TableDescription", encode_table_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_create_table_output_struct_top(
  input: CreateTableOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.table_description {
    option.Some(v) -> [
      #("TableDescription", encode_table_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_create_table_output_struct() -> decode.Decoder(CreateTableOutput) {
  use <- decode.recursive
  use table_description <- decode.optional_field(
    "TableDescription",
    option.None,
    decode.optional(decode_table_description_struct()),
  )
  decode.success(CreateTableOutput(table_description: table_description))
}

pub type TableDescription {
  TableDescription(
    archival_summary: option.Option(ArchivalSummary),
    attribute_definitions: option.Option(List(AttributeDefinition)),
    billing_mode_summary: option.Option(BillingModeSummary),
    creation_date_time: option.Option(json_timestamp.Timestamp),
    deletion_protection_enabled: option.Option(Bool),
    global_secondary_indexes: option.Option(
      List(GlobalSecondaryIndexDescription),
    ),
    global_table_settings_replication_mode: option.Option(
      GlobalTableSettingsReplicationMode,
    ),
    global_table_version: option.Option(String),
    global_table_witnesses: option.Option(List(GlobalTableWitnessDescription)),
    item_count: option.Option(Int),
    key_schema: option.Option(List(KeySchemaElement)),
    latest_stream_arn: option.Option(String),
    latest_stream_label: option.Option(String),
    local_secondary_indexes: option.Option(List(LocalSecondaryIndexDescription)),
    multi_region_consistency: option.Option(MultiRegionConsistency),
    on_demand_throughput: option.Option(OnDemandThroughput),
    provisioned_throughput: option.Option(ProvisionedThroughputDescription),
    replicas: option.Option(List(ReplicaDescription)),
    restore_summary: option.Option(RestoreSummary),
    sse_description: option.Option(SSEDescription),
    stream_specification: option.Option(StreamSpecification),
    table_arn: option.Option(String),
    table_class_summary: option.Option(TableClassSummary),
    table_id: option.Option(String),
    table_name: option.Option(String),
    table_size_bytes: option.Option(Int),
    table_status: option.Option(TableStatus),
    warm_throughput: option.Option(TableWarmThroughputDescription),
  )
}

pub fn table_description_default() -> TableDescription {
  TableDescription(
    archival_summary: option.None,
    attribute_definitions: option.None,
    billing_mode_summary: option.None,
    creation_date_time: option.None,
    deletion_protection_enabled: option.None,
    global_secondary_indexes: option.None,
    global_table_settings_replication_mode: option.None,
    global_table_version: option.None,
    global_table_witnesses: option.None,
    item_count: option.None,
    key_schema: option.None,
    latest_stream_arn: option.None,
    latest_stream_label: option.None,
    local_secondary_indexes: option.None,
    multi_region_consistency: option.None,
    on_demand_throughput: option.None,
    provisioned_throughput: option.None,
    replicas: option.None,
    restore_summary: option.None,
    sse_description: option.None,
    stream_specification: option.None,
    table_arn: option.None,
    table_class_summary: option.None,
    table_id: option.None,
    table_name: option.None,
    table_size_bytes: option.None,
    table_status: option.None,
    warm_throughput: option.None,
  )
}

pub fn encode_table_description_struct(input: TableDescription) -> json.Json {
  let pairs = []
  let pairs = case input.archival_summary {
    option.Some(v) -> [
      #("ArchivalSummary", encode_archival_summary_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.attribute_definitions {
    option.Some(v) -> [
      #(
        "AttributeDefinitions",
        fn(xs) { json.array(xs, encode_attribute_definition_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.billing_mode_summary {
    option.Some(v) -> [
      #("BillingModeSummary", encode_billing_mode_summary_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.creation_date_time {
    option.Some(v) -> [
      #("CreationDateTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.deletion_protection_enabled {
    option.Some(v) -> [#("DeletionProtectionEnabled", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.global_secondary_indexes {
    option.Some(v) -> [
      #(
        "GlobalSecondaryIndexes",
        fn(xs) {
          json.array(xs, encode_global_secondary_index_description_struct)
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.global_table_settings_replication_mode {
    option.Some(v) -> [
      #(
        "GlobalTableSettingsReplicationMode",
        encode_global_table_settings_replication_mode_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.global_table_version {
    option.Some(v) -> [#("GlobalTableVersion", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.global_table_witnesses {
    option.Some(v) -> [
      #(
        "GlobalTableWitnesses",
        fn(xs) {
          json.array(xs, encode_global_table_witness_description_struct)
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.item_count {
    option.Some(v) -> [#("ItemCount", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.key_schema {
    option.Some(v) -> [
      #(
        "KeySchema",
        fn(xs) { json.array(xs, encode_key_schema_element_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.latest_stream_arn {
    option.Some(v) -> [#("LatestStreamArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.latest_stream_label {
    option.Some(v) -> [#("LatestStreamLabel", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.local_secondary_indexes {
    option.Some(v) -> [
      #(
        "LocalSecondaryIndexes",
        fn(xs) {
          json.array(xs, encode_local_secondary_index_description_struct)
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.multi_region_consistency {
    option.Some(v) -> [
      #("MultiRegionConsistency", encode_multi_region_consistency_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.on_demand_throughput {
    option.Some(v) -> [
      #("OnDemandThroughput", encode_on_demand_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_throughput {
    option.Some(v) -> [
      #(
        "ProvisionedThroughput",
        encode_provisioned_throughput_description_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.replicas {
    option.Some(v) -> [
      #(
        "Replicas",
        fn(xs) { json.array(xs, encode_replica_description_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.restore_summary {
    option.Some(v) -> [
      #("RestoreSummary", encode_restore_summary_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.sse_description {
    option.Some(v) -> [
      #("SSEDescription", encode_sse_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.stream_specification {
    option.Some(v) -> [
      #("StreamSpecification", encode_stream_specification_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_arn {
    option.Some(v) -> [#("TableArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_class_summary {
    option.Some(v) -> [
      #("TableClassSummary", encode_table_class_summary_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_id {
    option.Some(v) -> [#("TableId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_size_bytes {
    option.Some(v) -> [#("TableSizeBytes", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_status {
    option.Some(v) -> [#("TableStatus", encode_table_status_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.warm_throughput {
    option.Some(v) -> [
      #("WarmThroughput", encode_table_warm_throughput_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_table_description_struct_top(
  input: TableDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.archival_summary {
    option.Some(v) -> [
      #("ArchivalSummary", encode_archival_summary_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.attribute_definitions {
    option.Some(v) -> [
      #(
        "AttributeDefinitions",
        fn(xs) { json.array(xs, encode_attribute_definition_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.billing_mode_summary {
    option.Some(v) -> [
      #("BillingModeSummary", encode_billing_mode_summary_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.creation_date_time {
    option.Some(v) -> [
      #("CreationDateTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.deletion_protection_enabled {
    option.Some(v) -> [#("DeletionProtectionEnabled", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.global_secondary_indexes {
    option.Some(v) -> [
      #(
        "GlobalSecondaryIndexes",
        fn(xs) {
          json.array(xs, encode_global_secondary_index_description_struct)
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.global_table_settings_replication_mode {
    option.Some(v) -> [
      #(
        "GlobalTableSettingsReplicationMode",
        encode_global_table_settings_replication_mode_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.global_table_version {
    option.Some(v) -> [#("GlobalTableVersion", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.global_table_witnesses {
    option.Some(v) -> [
      #(
        "GlobalTableWitnesses",
        fn(xs) {
          json.array(xs, encode_global_table_witness_description_struct)
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.item_count {
    option.Some(v) -> [#("ItemCount", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.key_schema {
    option.Some(v) -> [
      #(
        "KeySchema",
        fn(xs) { json.array(xs, encode_key_schema_element_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.latest_stream_arn {
    option.Some(v) -> [#("LatestStreamArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.latest_stream_label {
    option.Some(v) -> [#("LatestStreamLabel", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.local_secondary_indexes {
    option.Some(v) -> [
      #(
        "LocalSecondaryIndexes",
        fn(xs) {
          json.array(xs, encode_local_secondary_index_description_struct)
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.multi_region_consistency {
    option.Some(v) -> [
      #("MultiRegionConsistency", encode_multi_region_consistency_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.on_demand_throughput {
    option.Some(v) -> [
      #("OnDemandThroughput", encode_on_demand_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_throughput {
    option.Some(v) -> [
      #(
        "ProvisionedThroughput",
        encode_provisioned_throughput_description_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.replicas {
    option.Some(v) -> [
      #(
        "Replicas",
        fn(xs) { json.array(xs, encode_replica_description_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.restore_summary {
    option.Some(v) -> [
      #("RestoreSummary", encode_restore_summary_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.sse_description {
    option.Some(v) -> [
      #("SSEDescription", encode_sse_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.stream_specification {
    option.Some(v) -> [
      #("StreamSpecification", encode_stream_specification_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_arn {
    option.Some(v) -> [#("TableArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_class_summary {
    option.Some(v) -> [
      #("TableClassSummary", encode_table_class_summary_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_id {
    option.Some(v) -> [#("TableId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_size_bytes {
    option.Some(v) -> [#("TableSizeBytes", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_status {
    option.Some(v) -> [#("TableStatus", encode_table_status_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.warm_throughput {
    option.Some(v) -> [
      #("WarmThroughput", encode_table_warm_throughput_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_table_description_struct() -> decode.Decoder(TableDescription) {
  use <- decode.recursive
  use archival_summary <- decode.optional_field(
    "ArchivalSummary",
    option.None,
    decode.optional(decode_archival_summary_struct()),
  )
  use attribute_definitions <- decode.optional_field(
    "AttributeDefinitions",
    option.None,
    decode.optional(decode.list(decode_attribute_definition_struct())),
  )
  use billing_mode_summary <- decode.optional_field(
    "BillingModeSummary",
    option.None,
    decode.optional(decode_billing_mode_summary_struct()),
  )
  use creation_date_time <- decode.optional_field(
    "CreationDateTime",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use deletion_protection_enabled <- decode.optional_field(
    "DeletionProtectionEnabled",
    option.None,
    decode.optional(decode.bool),
  )
  use global_secondary_indexes <- decode.optional_field(
    "GlobalSecondaryIndexes",
    option.None,
    decode.optional(
      decode.list(decode_global_secondary_index_description_struct()),
    ),
  )
  use global_table_settings_replication_mode <- decode.optional_field(
    "GlobalTableSettingsReplicationMode",
    option.None,
    decode.optional(decode_global_table_settings_replication_mode_enum()),
  )
  use global_table_version <- decode.optional_field(
    "GlobalTableVersion",
    option.None,
    decode.optional(decode.string),
  )
  use global_table_witnesses <- decode.optional_field(
    "GlobalTableWitnesses",
    option.None,
    decode.optional(
      decode.list(decode_global_table_witness_description_struct()),
    ),
  )
  use item_count <- decode.optional_field(
    "ItemCount",
    option.None,
    decode.optional(decode.int),
  )
  use key_schema <- decode.optional_field(
    "KeySchema",
    option.None,
    decode.optional(decode.list(decode_key_schema_element_struct())),
  )
  use latest_stream_arn <- decode.optional_field(
    "LatestStreamArn",
    option.None,
    decode.optional(decode.string),
  )
  use latest_stream_label <- decode.optional_field(
    "LatestStreamLabel",
    option.None,
    decode.optional(decode.string),
  )
  use local_secondary_indexes <- decode.optional_field(
    "LocalSecondaryIndexes",
    option.None,
    decode.optional(
      decode.list(decode_local_secondary_index_description_struct()),
    ),
  )
  use multi_region_consistency <- decode.optional_field(
    "MultiRegionConsistency",
    option.None,
    decode.optional(decode_multi_region_consistency_enum()),
  )
  use on_demand_throughput <- decode.optional_field(
    "OnDemandThroughput",
    option.None,
    decode.optional(decode_on_demand_throughput_struct()),
  )
  use provisioned_throughput <- decode.optional_field(
    "ProvisionedThroughput",
    option.None,
    decode.optional(decode_provisioned_throughput_description_struct()),
  )
  use replicas <- decode.optional_field(
    "Replicas",
    option.None,
    decode.optional(decode.list(decode_replica_description_struct())),
  )
  use restore_summary <- decode.optional_field(
    "RestoreSummary",
    option.None,
    decode.optional(decode_restore_summary_struct()),
  )
  use sse_description <- decode.optional_field(
    "SSEDescription",
    option.None,
    decode.optional(decode_sse_description_struct()),
  )
  use stream_specification <- decode.optional_field(
    "StreamSpecification",
    option.None,
    decode.optional(decode_stream_specification_struct()),
  )
  use table_arn <- decode.optional_field(
    "TableArn",
    option.None,
    decode.optional(decode.string),
  )
  use table_class_summary <- decode.optional_field(
    "TableClassSummary",
    option.None,
    decode.optional(decode_table_class_summary_struct()),
  )
  use table_id <- decode.optional_field(
    "TableId",
    option.None,
    decode.optional(decode.string),
  )
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  use table_size_bytes <- decode.optional_field(
    "TableSizeBytes",
    option.None,
    decode.optional(decode.int),
  )
  use table_status <- decode.optional_field(
    "TableStatus",
    option.None,
    decode.optional(decode_table_status_enum()),
  )
  use warm_throughput <- decode.optional_field(
    "WarmThroughput",
    option.None,
    decode.optional(decode_table_warm_throughput_description_struct()),
  )
  decode.success(TableDescription(
    archival_summary: archival_summary,
    attribute_definitions: attribute_definitions,
    billing_mode_summary: billing_mode_summary,
    creation_date_time: creation_date_time,
    deletion_protection_enabled: deletion_protection_enabled,
    global_secondary_indexes: global_secondary_indexes,
    global_table_settings_replication_mode: global_table_settings_replication_mode,
    global_table_version: global_table_version,
    global_table_witnesses: global_table_witnesses,
    item_count: item_count,
    key_schema: key_schema,
    latest_stream_arn: latest_stream_arn,
    latest_stream_label: latest_stream_label,
    local_secondary_indexes: local_secondary_indexes,
    multi_region_consistency: multi_region_consistency,
    on_demand_throughput: on_demand_throughput,
    provisioned_throughput: provisioned_throughput,
    replicas: replicas,
    restore_summary: restore_summary,
    sse_description: sse_description,
    stream_specification: stream_specification,
    table_arn: table_arn,
    table_class_summary: table_class_summary,
    table_id: table_id,
    table_name: table_name,
    table_size_bytes: table_size_bytes,
    table_status: table_status,
    warm_throughput: warm_throughput,
  ))
}

pub type ArchivalSummary {
  ArchivalSummary(
    archival_backup_arn: option.Option(String),
    archival_date_time: option.Option(json_timestamp.Timestamp),
    archival_reason: option.Option(String),
  )
}

pub fn archival_summary_default() -> ArchivalSummary {
  ArchivalSummary(
    archival_backup_arn: option.None,
    archival_date_time: option.None,
    archival_reason: option.None,
  )
}

pub fn encode_archival_summary_struct(input: ArchivalSummary) -> json.Json {
  let pairs = []
  let pairs = case input.archival_backup_arn {
    option.Some(v) -> [#("ArchivalBackupArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.archival_date_time {
    option.Some(v) -> [
      #("ArchivalDateTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.archival_reason {
    option.Some(v) -> [#("ArchivalReason", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_archival_summary_struct_top(input: ArchivalSummary) -> json.Json {
  let pairs = []
  let pairs = case input.archival_backup_arn {
    option.Some(v) -> [#("ArchivalBackupArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.archival_date_time {
    option.Some(v) -> [
      #("ArchivalDateTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.archival_reason {
    option.Some(v) -> [#("ArchivalReason", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_archival_summary_struct() -> decode.Decoder(ArchivalSummary) {
  use <- decode.recursive
  use archival_backup_arn <- decode.optional_field(
    "ArchivalBackupArn",
    option.None,
    decode.optional(decode.string),
  )
  use archival_date_time <- decode.optional_field(
    "ArchivalDateTime",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use archival_reason <- decode.optional_field(
    "ArchivalReason",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ArchivalSummary(
    archival_backup_arn: archival_backup_arn,
    archival_date_time: archival_date_time,
    archival_reason: archival_reason,
  ))
}

pub type BillingModeSummary {
  BillingModeSummary(
    billing_mode: option.Option(BillingMode),
    last_update_to_pay_per_request_date_time: option.Option(
      json_timestamp.Timestamp,
    ),
  )
}

pub fn billing_mode_summary_default() -> BillingModeSummary {
  BillingModeSummary(
    billing_mode: option.None,
    last_update_to_pay_per_request_date_time: option.None,
  )
}

pub fn encode_billing_mode_summary_struct(
  input: BillingModeSummary,
) -> json.Json {
  let pairs = []
  let pairs = case input.billing_mode {
    option.Some(v) -> [#("BillingMode", encode_billing_mode_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.last_update_to_pay_per_request_date_time {
    option.Some(v) -> [
      #(
        "LastUpdateToPayPerRequestDateTime",
        json_timestamp.encode_epoch_seconds(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_billing_mode_summary_struct_top(
  input: BillingModeSummary,
) -> json.Json {
  let pairs = []
  let pairs = case input.billing_mode {
    option.Some(v) -> [#("BillingMode", encode_billing_mode_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.last_update_to_pay_per_request_date_time {
    option.Some(v) -> [
      #(
        "LastUpdateToPayPerRequestDateTime",
        json_timestamp.encode_epoch_seconds(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_billing_mode_summary_struct() -> decode.Decoder(
  BillingModeSummary,
) {
  use <- decode.recursive
  use billing_mode <- decode.optional_field(
    "BillingMode",
    option.None,
    decode.optional(decode_billing_mode_enum()),
  )
  use last_update_to_pay_per_request_date_time <- decode.optional_field(
    "LastUpdateToPayPerRequestDateTime",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  decode.success(BillingModeSummary(
    billing_mode: billing_mode,
    last_update_to_pay_per_request_date_time: last_update_to_pay_per_request_date_time,
  ))
}

pub type GlobalSecondaryIndexDescription {
  GlobalSecondaryIndexDescription(
    backfilling: option.Option(Bool),
    index_arn: option.Option(String),
    index_name: option.Option(String),
    index_size_bytes: option.Option(Int),
    index_status: option.Option(IndexStatus),
    item_count: option.Option(Int),
    key_schema: option.Option(List(KeySchemaElement)),
    on_demand_throughput: option.Option(OnDemandThroughput),
    projection: option.Option(Projection),
    provisioned_throughput: option.Option(ProvisionedThroughputDescription),
    warm_throughput: option.Option(
      GlobalSecondaryIndexWarmThroughputDescription,
    ),
  )
}

pub fn global_secondary_index_description_default() -> GlobalSecondaryIndexDescription {
  GlobalSecondaryIndexDescription(
    backfilling: option.None,
    index_arn: option.None,
    index_name: option.None,
    index_size_bytes: option.None,
    index_status: option.None,
    item_count: option.None,
    key_schema: option.None,
    on_demand_throughput: option.None,
    projection: option.None,
    provisioned_throughput: option.None,
    warm_throughput: option.None,
  )
}

pub fn encode_global_secondary_index_description_struct(
  input: GlobalSecondaryIndexDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.backfilling {
    option.Some(v) -> [#("Backfilling", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.index_arn {
    option.Some(v) -> [#("IndexArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.index_size_bytes {
    option.Some(v) -> [#("IndexSizeBytes", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.index_status {
    option.Some(v) -> [#("IndexStatus", encode_index_status_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.item_count {
    option.Some(v) -> [#("ItemCount", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.key_schema {
    option.Some(v) -> [
      #(
        "KeySchema",
        fn(xs) { json.array(xs, encode_key_schema_element_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.on_demand_throughput {
    option.Some(v) -> [
      #("OnDemandThroughput", encode_on_demand_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.projection {
    option.Some(v) -> [#("Projection", encode_projection_struct(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.provisioned_throughput {
    option.Some(v) -> [
      #(
        "ProvisionedThroughput",
        encode_provisioned_throughput_description_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.warm_throughput {
    option.Some(v) -> [
      #(
        "WarmThroughput",
        encode_global_secondary_index_warm_throughput_description_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_global_secondary_index_description_struct_top(
  input: GlobalSecondaryIndexDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.backfilling {
    option.Some(v) -> [#("Backfilling", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.index_arn {
    option.Some(v) -> [#("IndexArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.index_size_bytes {
    option.Some(v) -> [#("IndexSizeBytes", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.index_status {
    option.Some(v) -> [#("IndexStatus", encode_index_status_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.item_count {
    option.Some(v) -> [#("ItemCount", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.key_schema {
    option.Some(v) -> [
      #(
        "KeySchema",
        fn(xs) { json.array(xs, encode_key_schema_element_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.on_demand_throughput {
    option.Some(v) -> [
      #("OnDemandThroughput", encode_on_demand_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.projection {
    option.Some(v) -> [#("Projection", encode_projection_struct(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.provisioned_throughput {
    option.Some(v) -> [
      #(
        "ProvisionedThroughput",
        encode_provisioned_throughput_description_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.warm_throughput {
    option.Some(v) -> [
      #(
        "WarmThroughput",
        encode_global_secondary_index_warm_throughput_description_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_global_secondary_index_description_struct() -> decode.Decoder(
  GlobalSecondaryIndexDescription,
) {
  use <- decode.recursive
  use backfilling <- decode.optional_field(
    "Backfilling",
    option.None,
    decode.optional(decode.bool),
  )
  use index_arn <- decode.optional_field(
    "IndexArn",
    option.None,
    decode.optional(decode.string),
  )
  use index_name <- decode.optional_field(
    "IndexName",
    option.None,
    decode.optional(decode.string),
  )
  use index_size_bytes <- decode.optional_field(
    "IndexSizeBytes",
    option.None,
    decode.optional(decode.int),
  )
  use index_status <- decode.optional_field(
    "IndexStatus",
    option.None,
    decode.optional(decode_index_status_enum()),
  )
  use item_count <- decode.optional_field(
    "ItemCount",
    option.None,
    decode.optional(decode.int),
  )
  use key_schema <- decode.optional_field(
    "KeySchema",
    option.None,
    decode.optional(decode.list(decode_key_schema_element_struct())),
  )
  use on_demand_throughput <- decode.optional_field(
    "OnDemandThroughput",
    option.None,
    decode.optional(decode_on_demand_throughput_struct()),
  )
  use projection <- decode.optional_field(
    "Projection",
    option.None,
    decode.optional(decode_projection_struct()),
  )
  use provisioned_throughput <- decode.optional_field(
    "ProvisionedThroughput",
    option.None,
    decode.optional(decode_provisioned_throughput_description_struct()),
  )
  use warm_throughput <- decode.optional_field(
    "WarmThroughput",
    option.None,
    decode.optional(
      decode_global_secondary_index_warm_throughput_description_struct(),
    ),
  )
  decode.success(GlobalSecondaryIndexDescription(
    backfilling: backfilling,
    index_arn: index_arn,
    index_name: index_name,
    index_size_bytes: index_size_bytes,
    index_status: index_status,
    item_count: item_count,
    key_schema: key_schema,
    on_demand_throughput: on_demand_throughput,
    projection: projection,
    provisioned_throughput: provisioned_throughput,
    warm_throughput: warm_throughput,
  ))
}

pub type ProvisionedThroughputDescription {
  ProvisionedThroughputDescription(
    last_decrease_date_time: option.Option(json_timestamp.Timestamp),
    last_increase_date_time: option.Option(json_timestamp.Timestamp),
    number_of_decreases_today: option.Option(Int),
    read_capacity_units: option.Option(Int),
    write_capacity_units: option.Option(Int),
  )
}

pub fn provisioned_throughput_description_default() -> ProvisionedThroughputDescription {
  ProvisionedThroughputDescription(
    last_decrease_date_time: option.None,
    last_increase_date_time: option.None,
    number_of_decreases_today: option.None,
    read_capacity_units: option.None,
    write_capacity_units: option.None,
  )
}

pub fn encode_provisioned_throughput_description_struct(
  input: ProvisionedThroughputDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.last_decrease_date_time {
    option.Some(v) -> [
      #("LastDecreaseDateTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.last_increase_date_time {
    option.Some(v) -> [
      #("LastIncreaseDateTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.number_of_decreases_today {
    option.Some(v) -> [#("NumberOfDecreasesToday", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.read_capacity_units {
    option.Some(v) -> [#("ReadCapacityUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.write_capacity_units {
    option.Some(v) -> [#("WriteCapacityUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_provisioned_throughput_description_struct_top(
  input: ProvisionedThroughputDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.last_decrease_date_time {
    option.Some(v) -> [
      #("LastDecreaseDateTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.last_increase_date_time {
    option.Some(v) -> [
      #("LastIncreaseDateTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.number_of_decreases_today {
    option.Some(v) -> [#("NumberOfDecreasesToday", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.read_capacity_units {
    option.Some(v) -> [#("ReadCapacityUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.write_capacity_units {
    option.Some(v) -> [#("WriteCapacityUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_provisioned_throughput_description_struct() -> decode.Decoder(
  ProvisionedThroughputDescription,
) {
  use <- decode.recursive
  use last_decrease_date_time <- decode.optional_field(
    "LastDecreaseDateTime",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use last_increase_date_time <- decode.optional_field(
    "LastIncreaseDateTime",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use number_of_decreases_today <- decode.optional_field(
    "NumberOfDecreasesToday",
    option.None,
    decode.optional(decode.int),
  )
  use read_capacity_units <- decode.optional_field(
    "ReadCapacityUnits",
    option.None,
    decode.optional(decode.int),
  )
  use write_capacity_units <- decode.optional_field(
    "WriteCapacityUnits",
    option.None,
    decode.optional(decode.int),
  )
  decode.success(ProvisionedThroughputDescription(
    last_decrease_date_time: last_decrease_date_time,
    last_increase_date_time: last_increase_date_time,
    number_of_decreases_today: number_of_decreases_today,
    read_capacity_units: read_capacity_units,
    write_capacity_units: write_capacity_units,
  ))
}

pub type GlobalTableWitnessDescription {
  GlobalTableWitnessDescription(
    region_name: option.Option(String),
    witness_status: option.Option(WitnessStatus),
  )
}

pub fn global_table_witness_description_default() -> GlobalTableWitnessDescription {
  GlobalTableWitnessDescription(
    region_name: option.None,
    witness_status: option.None,
  )
}

pub fn encode_global_table_witness_description_struct(
  input: GlobalTableWitnessDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.region_name {
    option.Some(v) -> [#("RegionName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.witness_status {
    option.Some(v) -> [
      #("WitnessStatus", encode_witness_status_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_global_table_witness_description_struct_top(
  input: GlobalTableWitnessDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.region_name {
    option.Some(v) -> [#("RegionName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.witness_status {
    option.Some(v) -> [
      #("WitnessStatus", encode_witness_status_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_global_table_witness_description_struct() -> decode.Decoder(
  GlobalTableWitnessDescription,
) {
  use <- decode.recursive
  use region_name <- decode.optional_field(
    "RegionName",
    option.None,
    decode.optional(decode.string),
  )
  use witness_status <- decode.optional_field(
    "WitnessStatus",
    option.None,
    decode.optional(decode_witness_status_enum()),
  )
  decode.success(GlobalTableWitnessDescription(
    region_name: region_name,
    witness_status: witness_status,
  ))
}

pub type WitnessStatus {
  WitnessStatusActive
  WitnessStatusCreating
  WitnessStatusDeleting
}

pub fn encode_witness_status_enum(v: WitnessStatus) -> json.Json {
  case v {
    WitnessStatusActive -> json.string("ACTIVE")
    WitnessStatusCreating -> json.string("CREATING")
    WitnessStatusDeleting -> json.string("DELETING")
  }
}

pub fn decode_witness_status_enum() -> decode.Decoder(WitnessStatus) {
  decode.then(decode.string, fn(s) {
    case s {
      "ACTIVE" -> decode.success(WitnessStatusActive)
      "CREATING" -> decode.success(WitnessStatusCreating)
      "DELETING" -> decode.success(WitnessStatusDeleting)
      _ -> decode.failure(WitnessStatusActive, "unknown enum value")
    }
  })
}

pub type LocalSecondaryIndexDescription {
  LocalSecondaryIndexDescription(
    index_arn: option.Option(String),
    index_name: option.Option(String),
    index_size_bytes: option.Option(Int),
    item_count: option.Option(Int),
    key_schema: option.Option(List(KeySchemaElement)),
    projection: option.Option(Projection),
  )
}

pub fn local_secondary_index_description_default() -> LocalSecondaryIndexDescription {
  LocalSecondaryIndexDescription(
    index_arn: option.None,
    index_name: option.None,
    index_size_bytes: option.None,
    item_count: option.None,
    key_schema: option.None,
    projection: option.None,
  )
}

pub fn encode_local_secondary_index_description_struct(
  input: LocalSecondaryIndexDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.index_arn {
    option.Some(v) -> [#("IndexArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.index_size_bytes {
    option.Some(v) -> [#("IndexSizeBytes", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.item_count {
    option.Some(v) -> [#("ItemCount", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.key_schema {
    option.Some(v) -> [
      #(
        "KeySchema",
        fn(xs) { json.array(xs, encode_key_schema_element_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.projection {
    option.Some(v) -> [#("Projection", encode_projection_struct(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_local_secondary_index_description_struct_top(
  input: LocalSecondaryIndexDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.index_arn {
    option.Some(v) -> [#("IndexArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.index_size_bytes {
    option.Some(v) -> [#("IndexSizeBytes", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.item_count {
    option.Some(v) -> [#("ItemCount", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.key_schema {
    option.Some(v) -> [
      #(
        "KeySchema",
        fn(xs) { json.array(xs, encode_key_schema_element_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.projection {
    option.Some(v) -> [#("Projection", encode_projection_struct(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_local_secondary_index_description_struct() -> decode.Decoder(
  LocalSecondaryIndexDescription,
) {
  use <- decode.recursive
  use index_arn <- decode.optional_field(
    "IndexArn",
    option.None,
    decode.optional(decode.string),
  )
  use index_name <- decode.optional_field(
    "IndexName",
    option.None,
    decode.optional(decode.string),
  )
  use index_size_bytes <- decode.optional_field(
    "IndexSizeBytes",
    option.None,
    decode.optional(decode.int),
  )
  use item_count <- decode.optional_field(
    "ItemCount",
    option.None,
    decode.optional(decode.int),
  )
  use key_schema <- decode.optional_field(
    "KeySchema",
    option.None,
    decode.optional(decode.list(decode_key_schema_element_struct())),
  )
  use projection <- decode.optional_field(
    "Projection",
    option.None,
    decode.optional(decode_projection_struct()),
  )
  decode.success(LocalSecondaryIndexDescription(
    index_arn: index_arn,
    index_name: index_name,
    index_size_bytes: index_size_bytes,
    item_count: item_count,
    key_schema: key_schema,
    projection: projection,
  ))
}

pub type MultiRegionConsistency {
  MultiRegionConsistencyEventual
  MultiRegionConsistencyStrong
}

pub fn encode_multi_region_consistency_enum(
  v: MultiRegionConsistency,
) -> json.Json {
  case v {
    MultiRegionConsistencyEventual -> json.string("EVENTUAL")
    MultiRegionConsistencyStrong -> json.string("STRONG")
  }
}

pub fn decode_multi_region_consistency_enum() -> decode.Decoder(
  MultiRegionConsistency,
) {
  decode.then(decode.string, fn(s) {
    case s {
      "EVENTUAL" -> decode.success(MultiRegionConsistencyEventual)
      "STRONG" -> decode.success(MultiRegionConsistencyStrong)
      _ -> decode.failure(MultiRegionConsistencyEventual, "unknown enum value")
    }
  })
}

pub type RestoreSummary {
  RestoreSummary(
    restore_date_time: option.Option(json_timestamp.Timestamp),
    restore_in_progress: option.Option(Bool),
    source_backup_arn: option.Option(String),
    source_table_arn: option.Option(String),
  )
}

pub fn restore_summary_default() -> RestoreSummary {
  RestoreSummary(
    restore_date_time: option.None,
    restore_in_progress: option.None,
    source_backup_arn: option.None,
    source_table_arn: option.None,
  )
}

pub fn encode_restore_summary_struct(input: RestoreSummary) -> json.Json {
  let pairs = []
  let pairs = case input.restore_date_time {
    option.Some(v) -> [
      #("RestoreDateTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.restore_in_progress {
    option.Some(v) -> [#("RestoreInProgress", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.source_backup_arn {
    option.Some(v) -> [#("SourceBackupArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.source_table_arn {
    option.Some(v) -> [#("SourceTableArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_restore_summary_struct_top(input: RestoreSummary) -> json.Json {
  let pairs = []
  let pairs = case input.restore_date_time {
    option.Some(v) -> [
      #("RestoreDateTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.restore_in_progress {
    option.Some(v) -> [#("RestoreInProgress", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.source_backup_arn {
    option.Some(v) -> [#("SourceBackupArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.source_table_arn {
    option.Some(v) -> [#("SourceTableArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_restore_summary_struct() -> decode.Decoder(RestoreSummary) {
  use <- decode.recursive
  use restore_date_time <- decode.optional_field(
    "RestoreDateTime",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use restore_in_progress <- decode.optional_field(
    "RestoreInProgress",
    option.None,
    decode.optional(decode.bool),
  )
  use source_backup_arn <- decode.optional_field(
    "SourceBackupArn",
    option.None,
    decode.optional(decode.string),
  )
  use source_table_arn <- decode.optional_field(
    "SourceTableArn",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(RestoreSummary(
    restore_date_time: restore_date_time,
    restore_in_progress: restore_in_progress,
    source_backup_arn: source_backup_arn,
    source_table_arn: source_table_arn,
  ))
}

pub type SSEDescription {
  SSEDescription(
    inaccessible_encryption_date_time: option.Option(json_timestamp.Timestamp),
    kms_master_key_arn: option.Option(String),
    sse_type: option.Option(SSEType),
    status: option.Option(SSEStatus),
  )
}

pub fn sse_description_default() -> SSEDescription {
  SSEDescription(
    inaccessible_encryption_date_time: option.None,
    kms_master_key_arn: option.None,
    sse_type: option.None,
    status: option.None,
  )
}

pub fn encode_sse_description_struct(input: SSEDescription) -> json.Json {
  let pairs = []
  let pairs = case input.inaccessible_encryption_date_time {
    option.Some(v) -> [
      #(
        "InaccessibleEncryptionDateTime",
        json_timestamp.encode_epoch_seconds(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.kms_master_key_arn {
    option.Some(v) -> [#("KMSMasterKeyArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.sse_type {
    option.Some(v) -> [#("SSEType", encode_sse_type_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.status {
    option.Some(v) -> [#("Status", encode_sse_status_enum(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_sse_description_struct_top(input: SSEDescription) -> json.Json {
  let pairs = []
  let pairs = case input.inaccessible_encryption_date_time {
    option.Some(v) -> [
      #(
        "InaccessibleEncryptionDateTime",
        json_timestamp.encode_epoch_seconds(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.kms_master_key_arn {
    option.Some(v) -> [#("KMSMasterKeyArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.sse_type {
    option.Some(v) -> [#("SSEType", encode_sse_type_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.status {
    option.Some(v) -> [#("Status", encode_sse_status_enum(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_sse_description_struct() -> decode.Decoder(SSEDescription) {
  use <- decode.recursive
  use inaccessible_encryption_date_time <- decode.optional_field(
    "InaccessibleEncryptionDateTime",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use kms_master_key_arn <- decode.optional_field(
    "KMSMasterKeyArn",
    option.None,
    decode.optional(decode.string),
  )
  use sse_type <- decode.optional_field(
    "SSEType",
    option.None,
    decode.optional(decode_sse_type_enum()),
  )
  use status <- decode.optional_field(
    "Status",
    option.None,
    decode.optional(decode_sse_status_enum()),
  )
  decode.success(SSEDescription(
    inaccessible_encryption_date_time: inaccessible_encryption_date_time,
    kms_master_key_arn: kms_master_key_arn,
    sse_type: sse_type,
    status: status,
  ))
}

pub type SSEStatus {
  SSEStatusDisabled
  SSEStatusDisabling
  SSEStatusEnabled
  SSEStatusEnabling
  SSEStatusUpdating
}

pub fn encode_sse_status_enum(v: SSEStatus) -> json.Json {
  case v {
    SSEStatusDisabled -> json.string("DISABLED")
    SSEStatusDisabling -> json.string("DISABLING")
    SSEStatusEnabled -> json.string("ENABLED")
    SSEStatusEnabling -> json.string("ENABLING")
    SSEStatusUpdating -> json.string("UPDATING")
  }
}

pub fn decode_sse_status_enum() -> decode.Decoder(SSEStatus) {
  decode.then(decode.string, fn(s) {
    case s {
      "DISABLED" -> decode.success(SSEStatusDisabled)
      "DISABLING" -> decode.success(SSEStatusDisabling)
      "ENABLED" -> decode.success(SSEStatusEnabled)
      "ENABLING" -> decode.success(SSEStatusEnabling)
      "UPDATING" -> decode.success(SSEStatusUpdating)
      _ -> decode.failure(SSEStatusDisabled, "unknown enum value")
    }
  })
}

pub type ResourceInUseException {
  ResourceInUseException(message: option.Option(String))
}

pub fn resource_in_use_exception_default() -> ResourceInUseException {
  ResourceInUseException(message: option.None)
}

pub fn encode_resource_in_use_exception_struct(
  input: ResourceInUseException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_resource_in_use_exception_struct_top(
  input: ResourceInUseException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_resource_in_use_exception_struct() -> decode.Decoder(
  ResourceInUseException,
) {
  use <- decode.recursive
  use message <- decode.optional_field(
    "message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ResourceInUseException(message: message))
}

pub type DeleteBackupInput {
  DeleteBackupInput(backup_arn: option.Option(String))
}

pub fn delete_backup_input_default() -> DeleteBackupInput {
  DeleteBackupInput(backup_arn: option.None)
}

pub fn encode_delete_backup_input_struct(
  input: DeleteBackupInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.backup_arn {
    option.Some(v) -> [#("BackupArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_delete_backup_input_struct_top(
  input: DeleteBackupInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.backup_arn {
    option.Some(v) -> [#("BackupArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_delete_backup_input_struct() -> decode.Decoder(DeleteBackupInput) {
  use <- decode.recursive
  use backup_arn <- decode.optional_field(
    "BackupArn",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteBackupInput(backup_arn: backup_arn))
}

pub type DeleteBackupOutput {
  DeleteBackupOutput(backup_description: option.Option(BackupDescription))
}

pub fn delete_backup_output_default() -> DeleteBackupOutput {
  DeleteBackupOutput(backup_description: option.None)
}

pub fn encode_delete_backup_output_struct(
  input: DeleteBackupOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.backup_description {
    option.Some(v) -> [
      #("BackupDescription", encode_backup_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_delete_backup_output_struct_top(
  input: DeleteBackupOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.backup_description {
    option.Some(v) -> [
      #("BackupDescription", encode_backup_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_delete_backup_output_struct() -> decode.Decoder(
  DeleteBackupOutput,
) {
  use <- decode.recursive
  use backup_description <- decode.optional_field(
    "BackupDescription",
    option.None,
    decode.optional(decode_backup_description_struct()),
  )
  decode.success(DeleteBackupOutput(backup_description: backup_description))
}

pub type BackupDescription {
  BackupDescription(
    backup_details: option.Option(BackupDetails),
    source_table_details: option.Option(SourceTableDetails),
    source_table_feature_details: option.Option(SourceTableFeatureDetails),
  )
}

pub fn backup_description_default() -> BackupDescription {
  BackupDescription(
    backup_details: option.None,
    source_table_details: option.None,
    source_table_feature_details: option.None,
  )
}

pub fn encode_backup_description_struct(input: BackupDescription) -> json.Json {
  let pairs = []
  let pairs = case input.backup_details {
    option.Some(v) -> [
      #("BackupDetails", encode_backup_details_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.source_table_details {
    option.Some(v) -> [
      #("SourceTableDetails", encode_source_table_details_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.source_table_feature_details {
    option.Some(v) -> [
      #(
        "SourceTableFeatureDetails",
        encode_source_table_feature_details_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_backup_description_struct_top(
  input: BackupDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.backup_details {
    option.Some(v) -> [
      #("BackupDetails", encode_backup_details_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.source_table_details {
    option.Some(v) -> [
      #("SourceTableDetails", encode_source_table_details_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.source_table_feature_details {
    option.Some(v) -> [
      #(
        "SourceTableFeatureDetails",
        encode_source_table_feature_details_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_backup_description_struct() -> decode.Decoder(BackupDescription) {
  use <- decode.recursive
  use backup_details <- decode.optional_field(
    "BackupDetails",
    option.None,
    decode.optional(decode_backup_details_struct()),
  )
  use source_table_details <- decode.optional_field(
    "SourceTableDetails",
    option.None,
    decode.optional(decode_source_table_details_struct()),
  )
  use source_table_feature_details <- decode.optional_field(
    "SourceTableFeatureDetails",
    option.None,
    decode.optional(decode_source_table_feature_details_struct()),
  )
  decode.success(BackupDescription(
    backup_details: backup_details,
    source_table_details: source_table_details,
    source_table_feature_details: source_table_feature_details,
  ))
}

pub type SourceTableDetails {
  SourceTableDetails(
    billing_mode: option.Option(BillingMode),
    item_count: option.Option(Int),
    key_schema: option.Option(List(KeySchemaElement)),
    on_demand_throughput: option.Option(OnDemandThroughput),
    provisioned_throughput: option.Option(ProvisionedThroughput),
    table_arn: option.Option(String),
    table_creation_date_time: option.Option(json_timestamp.Timestamp),
    table_id: option.Option(String),
    table_name: option.Option(String),
    table_size_bytes: option.Option(Int),
  )
}

pub fn source_table_details_default() -> SourceTableDetails {
  SourceTableDetails(
    billing_mode: option.None,
    item_count: option.None,
    key_schema: option.None,
    on_demand_throughput: option.None,
    provisioned_throughput: option.None,
    table_arn: option.None,
    table_creation_date_time: option.None,
    table_id: option.None,
    table_name: option.None,
    table_size_bytes: option.None,
  )
}

pub fn encode_source_table_details_struct(
  input: SourceTableDetails,
) -> json.Json {
  let pairs = []
  let pairs = case input.billing_mode {
    option.Some(v) -> [#("BillingMode", encode_billing_mode_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.item_count {
    option.Some(v) -> [#("ItemCount", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.key_schema {
    option.Some(v) -> [
      #(
        "KeySchema",
        fn(xs) { json.array(xs, encode_key_schema_element_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.on_demand_throughput {
    option.Some(v) -> [
      #("OnDemandThroughput", encode_on_demand_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_throughput {
    option.Some(v) -> [
      #("ProvisionedThroughput", encode_provisioned_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_arn {
    option.Some(v) -> [#("TableArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_creation_date_time {
    option.Some(v) -> [
      #("TableCreationDateTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_id {
    option.Some(v) -> [#("TableId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_size_bytes {
    option.Some(v) -> [#("TableSizeBytes", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_source_table_details_struct_top(
  input: SourceTableDetails,
) -> json.Json {
  let pairs = []
  let pairs = case input.billing_mode {
    option.Some(v) -> [#("BillingMode", encode_billing_mode_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.item_count {
    option.Some(v) -> [#("ItemCount", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.key_schema {
    option.Some(v) -> [
      #(
        "KeySchema",
        fn(xs) { json.array(xs, encode_key_schema_element_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.on_demand_throughput {
    option.Some(v) -> [
      #("OnDemandThroughput", encode_on_demand_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_throughput {
    option.Some(v) -> [
      #("ProvisionedThroughput", encode_provisioned_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_arn {
    option.Some(v) -> [#("TableArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_creation_date_time {
    option.Some(v) -> [
      #("TableCreationDateTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_id {
    option.Some(v) -> [#("TableId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_size_bytes {
    option.Some(v) -> [#("TableSizeBytes", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_source_table_details_struct() -> decode.Decoder(
  SourceTableDetails,
) {
  use <- decode.recursive
  use billing_mode <- decode.optional_field(
    "BillingMode",
    option.None,
    decode.optional(decode_billing_mode_enum()),
  )
  use item_count <- decode.optional_field(
    "ItemCount",
    option.None,
    decode.optional(decode.int),
  )
  use key_schema <- decode.optional_field(
    "KeySchema",
    option.None,
    decode.optional(decode.list(decode_key_schema_element_struct())),
  )
  use on_demand_throughput <- decode.optional_field(
    "OnDemandThroughput",
    option.None,
    decode.optional(decode_on_demand_throughput_struct()),
  )
  use provisioned_throughput <- decode.optional_field(
    "ProvisionedThroughput",
    option.None,
    decode.optional(decode_provisioned_throughput_struct()),
  )
  use table_arn <- decode.optional_field(
    "TableArn",
    option.None,
    decode.optional(decode.string),
  )
  use table_creation_date_time <- decode.optional_field(
    "TableCreationDateTime",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use table_id <- decode.optional_field(
    "TableId",
    option.None,
    decode.optional(decode.string),
  )
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  use table_size_bytes <- decode.optional_field(
    "TableSizeBytes",
    option.None,
    decode.optional(decode.int),
  )
  decode.success(SourceTableDetails(
    billing_mode: billing_mode,
    item_count: item_count,
    key_schema: key_schema,
    on_demand_throughput: on_demand_throughput,
    provisioned_throughput: provisioned_throughput,
    table_arn: table_arn,
    table_creation_date_time: table_creation_date_time,
    table_id: table_id,
    table_name: table_name,
    table_size_bytes: table_size_bytes,
  ))
}

pub type SourceTableFeatureDetails {
  SourceTableFeatureDetails(
    global_secondary_indexes: option.Option(List(GlobalSecondaryIndexInfo)),
    local_secondary_indexes: option.Option(List(LocalSecondaryIndexInfo)),
    sse_description: option.Option(SSEDescription),
    stream_description: option.Option(StreamSpecification),
    time_to_live_description: option.Option(TimeToLiveDescription),
  )
}

pub fn source_table_feature_details_default() -> SourceTableFeatureDetails {
  SourceTableFeatureDetails(
    global_secondary_indexes: option.None,
    local_secondary_indexes: option.None,
    sse_description: option.None,
    stream_description: option.None,
    time_to_live_description: option.None,
  )
}

pub fn encode_source_table_feature_details_struct(
  input: SourceTableFeatureDetails,
) -> json.Json {
  let pairs = []
  let pairs = case input.global_secondary_indexes {
    option.Some(v) -> [
      #(
        "GlobalSecondaryIndexes",
        fn(xs) { json.array(xs, encode_global_secondary_index_info_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.local_secondary_indexes {
    option.Some(v) -> [
      #(
        "LocalSecondaryIndexes",
        fn(xs) { json.array(xs, encode_local_secondary_index_info_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.sse_description {
    option.Some(v) -> [
      #("SSEDescription", encode_sse_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.stream_description {
    option.Some(v) -> [
      #("StreamDescription", encode_stream_specification_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.time_to_live_description {
    option.Some(v) -> [
      #("TimeToLiveDescription", encode_time_to_live_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_source_table_feature_details_struct_top(
  input: SourceTableFeatureDetails,
) -> json.Json {
  let pairs = []
  let pairs = case input.global_secondary_indexes {
    option.Some(v) -> [
      #(
        "GlobalSecondaryIndexes",
        fn(xs) { json.array(xs, encode_global_secondary_index_info_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.local_secondary_indexes {
    option.Some(v) -> [
      #(
        "LocalSecondaryIndexes",
        fn(xs) { json.array(xs, encode_local_secondary_index_info_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.sse_description {
    option.Some(v) -> [
      #("SSEDescription", encode_sse_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.stream_description {
    option.Some(v) -> [
      #("StreamDescription", encode_stream_specification_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.time_to_live_description {
    option.Some(v) -> [
      #("TimeToLiveDescription", encode_time_to_live_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_source_table_feature_details_struct() -> decode.Decoder(
  SourceTableFeatureDetails,
) {
  use <- decode.recursive
  use global_secondary_indexes <- decode.optional_field(
    "GlobalSecondaryIndexes",
    option.None,
    decode.optional(decode.list(decode_global_secondary_index_info_struct())),
  )
  use local_secondary_indexes <- decode.optional_field(
    "LocalSecondaryIndexes",
    option.None,
    decode.optional(decode.list(decode_local_secondary_index_info_struct())),
  )
  use sse_description <- decode.optional_field(
    "SSEDescription",
    option.None,
    decode.optional(decode_sse_description_struct()),
  )
  use stream_description <- decode.optional_field(
    "StreamDescription",
    option.None,
    decode.optional(decode_stream_specification_struct()),
  )
  use time_to_live_description <- decode.optional_field(
    "TimeToLiveDescription",
    option.None,
    decode.optional(decode_time_to_live_description_struct()),
  )
  decode.success(SourceTableFeatureDetails(
    global_secondary_indexes: global_secondary_indexes,
    local_secondary_indexes: local_secondary_indexes,
    sse_description: sse_description,
    stream_description: stream_description,
    time_to_live_description: time_to_live_description,
  ))
}

pub type GlobalSecondaryIndexInfo {
  GlobalSecondaryIndexInfo(
    index_name: option.Option(String),
    key_schema: option.Option(List(KeySchemaElement)),
    on_demand_throughput: option.Option(OnDemandThroughput),
    projection: option.Option(Projection),
    provisioned_throughput: option.Option(ProvisionedThroughput),
  )
}

pub fn global_secondary_index_info_default() -> GlobalSecondaryIndexInfo {
  GlobalSecondaryIndexInfo(
    index_name: option.None,
    key_schema: option.None,
    on_demand_throughput: option.None,
    projection: option.None,
    provisioned_throughput: option.None,
  )
}

pub fn encode_global_secondary_index_info_struct(
  input: GlobalSecondaryIndexInfo,
) -> json.Json {
  let pairs = []
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.key_schema {
    option.Some(v) -> [
      #(
        "KeySchema",
        fn(xs) { json.array(xs, encode_key_schema_element_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.on_demand_throughput {
    option.Some(v) -> [
      #("OnDemandThroughput", encode_on_demand_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.projection {
    option.Some(v) -> [#("Projection", encode_projection_struct(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.provisioned_throughput {
    option.Some(v) -> [
      #("ProvisionedThroughput", encode_provisioned_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_global_secondary_index_info_struct_top(
  input: GlobalSecondaryIndexInfo,
) -> json.Json {
  let pairs = []
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.key_schema {
    option.Some(v) -> [
      #(
        "KeySchema",
        fn(xs) { json.array(xs, encode_key_schema_element_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.on_demand_throughput {
    option.Some(v) -> [
      #("OnDemandThroughput", encode_on_demand_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.projection {
    option.Some(v) -> [#("Projection", encode_projection_struct(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.provisioned_throughput {
    option.Some(v) -> [
      #("ProvisionedThroughput", encode_provisioned_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_global_secondary_index_info_struct() -> decode.Decoder(
  GlobalSecondaryIndexInfo,
) {
  use <- decode.recursive
  use index_name <- decode.optional_field(
    "IndexName",
    option.None,
    decode.optional(decode.string),
  )
  use key_schema <- decode.optional_field(
    "KeySchema",
    option.None,
    decode.optional(decode.list(decode_key_schema_element_struct())),
  )
  use on_demand_throughput <- decode.optional_field(
    "OnDemandThroughput",
    option.None,
    decode.optional(decode_on_demand_throughput_struct()),
  )
  use projection <- decode.optional_field(
    "Projection",
    option.None,
    decode.optional(decode_projection_struct()),
  )
  use provisioned_throughput <- decode.optional_field(
    "ProvisionedThroughput",
    option.None,
    decode.optional(decode_provisioned_throughput_struct()),
  )
  decode.success(GlobalSecondaryIndexInfo(
    index_name: index_name,
    key_schema: key_schema,
    on_demand_throughput: on_demand_throughput,
    projection: projection,
    provisioned_throughput: provisioned_throughput,
  ))
}

pub type LocalSecondaryIndexInfo {
  LocalSecondaryIndexInfo(
    index_name: option.Option(String),
    key_schema: option.Option(List(KeySchemaElement)),
    projection: option.Option(Projection),
  )
}

pub fn local_secondary_index_info_default() -> LocalSecondaryIndexInfo {
  LocalSecondaryIndexInfo(
    index_name: option.None,
    key_schema: option.None,
    projection: option.None,
  )
}

pub fn encode_local_secondary_index_info_struct(
  input: LocalSecondaryIndexInfo,
) -> json.Json {
  let pairs = []
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.key_schema {
    option.Some(v) -> [
      #(
        "KeySchema",
        fn(xs) { json.array(xs, encode_key_schema_element_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.projection {
    option.Some(v) -> [#("Projection", encode_projection_struct(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_local_secondary_index_info_struct_top(
  input: LocalSecondaryIndexInfo,
) -> json.Json {
  let pairs = []
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.key_schema {
    option.Some(v) -> [
      #(
        "KeySchema",
        fn(xs) { json.array(xs, encode_key_schema_element_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.projection {
    option.Some(v) -> [#("Projection", encode_projection_struct(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_local_secondary_index_info_struct() -> decode.Decoder(
  LocalSecondaryIndexInfo,
) {
  use <- decode.recursive
  use index_name <- decode.optional_field(
    "IndexName",
    option.None,
    decode.optional(decode.string),
  )
  use key_schema <- decode.optional_field(
    "KeySchema",
    option.None,
    decode.optional(decode.list(decode_key_schema_element_struct())),
  )
  use projection <- decode.optional_field(
    "Projection",
    option.None,
    decode.optional(decode_projection_struct()),
  )
  decode.success(LocalSecondaryIndexInfo(
    index_name: index_name,
    key_schema: key_schema,
    projection: projection,
  ))
}

pub type TimeToLiveDescription {
  TimeToLiveDescription(
    attribute_name: option.Option(String),
    time_to_live_status: option.Option(TimeToLiveStatus),
  )
}

pub fn time_to_live_description_default() -> TimeToLiveDescription {
  TimeToLiveDescription(
    attribute_name: option.None,
    time_to_live_status: option.None,
  )
}

pub fn encode_time_to_live_description_struct(
  input: TimeToLiveDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.attribute_name {
    option.Some(v) -> [#("AttributeName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.time_to_live_status {
    option.Some(v) -> [
      #("TimeToLiveStatus", encode_time_to_live_status_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_time_to_live_description_struct_top(
  input: TimeToLiveDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.attribute_name {
    option.Some(v) -> [#("AttributeName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.time_to_live_status {
    option.Some(v) -> [
      #("TimeToLiveStatus", encode_time_to_live_status_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_time_to_live_description_struct() -> decode.Decoder(
  TimeToLiveDescription,
) {
  use <- decode.recursive
  use attribute_name <- decode.optional_field(
    "AttributeName",
    option.None,
    decode.optional(decode.string),
  )
  use time_to_live_status <- decode.optional_field(
    "TimeToLiveStatus",
    option.None,
    decode.optional(decode_time_to_live_status_enum()),
  )
  decode.success(TimeToLiveDescription(
    attribute_name: attribute_name,
    time_to_live_status: time_to_live_status,
  ))
}

pub type TimeToLiveStatus {
  TimeToLiveStatusDisabled
  TimeToLiveStatusDisabling
  TimeToLiveStatusEnabled
  TimeToLiveStatusEnabling
}

pub fn encode_time_to_live_status_enum(v: TimeToLiveStatus) -> json.Json {
  case v {
    TimeToLiveStatusDisabled -> json.string("DISABLED")
    TimeToLiveStatusDisabling -> json.string("DISABLING")
    TimeToLiveStatusEnabled -> json.string("ENABLED")
    TimeToLiveStatusEnabling -> json.string("ENABLING")
  }
}

pub fn decode_time_to_live_status_enum() -> decode.Decoder(TimeToLiveStatus) {
  decode.then(decode.string, fn(s) {
    case s {
      "DISABLED" -> decode.success(TimeToLiveStatusDisabled)
      "DISABLING" -> decode.success(TimeToLiveStatusDisabling)
      "ENABLED" -> decode.success(TimeToLiveStatusEnabled)
      "ENABLING" -> decode.success(TimeToLiveStatusEnabling)
      _ -> decode.failure(TimeToLiveStatusDisabled, "unknown enum value")
    }
  })
}

pub type BackupNotFoundException {
  BackupNotFoundException(message: option.Option(String))
}

pub fn backup_not_found_exception_default() -> BackupNotFoundException {
  BackupNotFoundException(message: option.None)
}

pub fn encode_backup_not_found_exception_struct(
  input: BackupNotFoundException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_backup_not_found_exception_struct_top(
  input: BackupNotFoundException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_backup_not_found_exception_struct() -> decode.Decoder(
  BackupNotFoundException,
) {
  use <- decode.recursive
  use message <- decode.optional_field(
    "message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(BackupNotFoundException(message: message))
}

pub type DeleteItemInput {
  DeleteItemInput(
    condition_expression: option.Option(String),
    conditional_operator: option.Option(ConditionalOperator),
    expected: option.Option(dict.Dict(String, ExpectedAttributeValue)),
    expression_attribute_names: option.Option(dict.Dict(String, String)),
    expression_attribute_values: option.Option(
      dict.Dict(String, AttributeValue),
    ),
    key: option.Option(dict.Dict(String, AttributeValue)),
    return_consumed_capacity: option.Option(ReturnConsumedCapacity),
    return_item_collection_metrics: option.Option(ReturnItemCollectionMetrics),
    return_values: option.Option(ReturnValue),
    return_values_on_condition_check_failure: option.Option(
      ReturnValuesOnConditionCheckFailure,
    ),
    table_name: option.Option(String),
  )
}

pub fn delete_item_input_default() -> DeleteItemInput {
  DeleteItemInput(
    condition_expression: option.None,
    conditional_operator: option.None,
    expected: option.None,
    expression_attribute_names: option.None,
    expression_attribute_values: option.None,
    key: option.None,
    return_consumed_capacity: option.None,
    return_item_collection_metrics: option.None,
    return_values: option.None,
    return_values_on_condition_check_failure: option.None,
    table_name: option.None,
  )
}

pub fn encode_delete_item_input_struct(input: DeleteItemInput) -> json.Json {
  let pairs = []
  let pairs = case input.condition_expression {
    option.Some(v) -> [#("ConditionExpression", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.conditional_operator {
    option.Some(v) -> [
      #("ConditionalOperator", encode_conditional_operator_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.expected {
    option.Some(v) -> [
      #(
        "Expected",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_expected_attribute_value_struct(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_names {
    option.Some(v) -> [
      #(
        "ExpressionAttributeNames",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_values {
    option.Some(v) -> [
      #(
        "ExpressionAttributeValues",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.key {
    option.Some(v) -> [
      #(
        "Key",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_consumed_capacity {
    option.Some(v) -> [
      #("ReturnConsumedCapacity", encode_return_consumed_capacity_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_item_collection_metrics {
    option.Some(v) -> [
      #(
        "ReturnItemCollectionMetrics",
        encode_return_item_collection_metrics_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_values {
    option.Some(v) -> [#("ReturnValues", encode_return_value_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.return_values_on_condition_check_failure {
    option.Some(v) -> [
      #(
        "ReturnValuesOnConditionCheckFailure",
        encode_return_values_on_condition_check_failure_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_delete_item_input_struct_top(
  input: DeleteItemInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.condition_expression {
    option.Some(v) -> [#("ConditionExpression", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.conditional_operator {
    option.Some(v) -> [
      #("ConditionalOperator", encode_conditional_operator_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.expected {
    option.Some(v) -> [
      #(
        "Expected",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_expected_attribute_value_struct(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_names {
    option.Some(v) -> [
      #(
        "ExpressionAttributeNames",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_values {
    option.Some(v) -> [
      #(
        "ExpressionAttributeValues",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.key {
    option.Some(v) -> [
      #(
        "Key",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_consumed_capacity {
    option.Some(v) -> [
      #("ReturnConsumedCapacity", encode_return_consumed_capacity_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_item_collection_metrics {
    option.Some(v) -> [
      #(
        "ReturnItemCollectionMetrics",
        encode_return_item_collection_metrics_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_values {
    option.Some(v) -> [#("ReturnValues", encode_return_value_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.return_values_on_condition_check_failure {
    option.Some(v) -> [
      #(
        "ReturnValuesOnConditionCheckFailure",
        encode_return_values_on_condition_check_failure_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_delete_item_input_struct() -> decode.Decoder(DeleteItemInput) {
  use <- decode.recursive
  use condition_expression <- decode.optional_field(
    "ConditionExpression",
    option.None,
    decode.optional(decode.string),
  )
  use conditional_operator <- decode.optional_field(
    "ConditionalOperator",
    option.None,
    decode.optional(decode_conditional_operator_enum()),
  )
  use expected <- decode.optional_field(
    "Expected",
    option.None,
    decode.optional(decode.dict(
      decode.string,
      decode_expected_attribute_value_struct(),
    )),
  )
  use expression_attribute_names <- decode.optional_field(
    "ExpressionAttributeNames",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use expression_attribute_values <- decode.optional_field(
    "ExpressionAttributeValues",
    option.None,
    decode.optional(decode.dict(decode.string, decode_attribute_value_union())),
  )
  use key <- decode.optional_field(
    "Key",
    option.None,
    decode.optional(decode.dict(decode.string, decode_attribute_value_union())),
  )
  use return_consumed_capacity <- decode.optional_field(
    "ReturnConsumedCapacity",
    option.None,
    decode.optional(decode_return_consumed_capacity_enum()),
  )
  use return_item_collection_metrics <- decode.optional_field(
    "ReturnItemCollectionMetrics",
    option.None,
    decode.optional(decode_return_item_collection_metrics_enum()),
  )
  use return_values <- decode.optional_field(
    "ReturnValues",
    option.None,
    decode.optional(decode_return_value_enum()),
  )
  use return_values_on_condition_check_failure <- decode.optional_field(
    "ReturnValuesOnConditionCheckFailure",
    option.None,
    decode.optional(decode_return_values_on_condition_check_failure_enum()),
  )
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteItemInput(
    condition_expression: condition_expression,
    conditional_operator: conditional_operator,
    expected: expected,
    expression_attribute_names: expression_attribute_names,
    expression_attribute_values: expression_attribute_values,
    key: key,
    return_consumed_capacity: return_consumed_capacity,
    return_item_collection_metrics: return_item_collection_metrics,
    return_values: return_values,
    return_values_on_condition_check_failure: return_values_on_condition_check_failure,
    table_name: table_name,
  ))
}

pub type ConditionalOperator {
  ConditionalOperatorAnd
  ConditionalOperatorOr
}

pub fn encode_conditional_operator_enum(v: ConditionalOperator) -> json.Json {
  case v {
    ConditionalOperatorAnd -> json.string("AND")
    ConditionalOperatorOr -> json.string("OR")
  }
}

pub fn decode_conditional_operator_enum() -> decode.Decoder(ConditionalOperator) {
  decode.then(decode.string, fn(s) {
    case s {
      "AND" -> decode.success(ConditionalOperatorAnd)
      "OR" -> decode.success(ConditionalOperatorOr)
      _ -> decode.failure(ConditionalOperatorAnd, "unknown enum value")
    }
  })
}

pub type ExpectedAttributeValue {
  ExpectedAttributeValue(
    attribute_value_list: option.Option(List(AttributeValue)),
    comparison_operator: option.Option(ComparisonOperator),
    exists: option.Option(Bool),
    value: option.Option(AttributeValue),
  )
}

pub fn expected_attribute_value_default() -> ExpectedAttributeValue {
  ExpectedAttributeValue(
    attribute_value_list: option.None,
    comparison_operator: option.None,
    exists: option.None,
    value: option.None,
  )
}

pub fn encode_expected_attribute_value_struct(
  input: ExpectedAttributeValue,
) -> json.Json {
  let pairs = []
  let pairs = case input.attribute_value_list {
    option.Some(v) -> [
      #(
        "AttributeValueList",
        fn(xs) { json.array(xs, encode_attribute_value_union) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.comparison_operator {
    option.Some(v) -> [
      #("ComparisonOperator", encode_comparison_operator_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.exists {
    option.Some(v) -> [#("Exists", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.value {
    option.Some(v) -> [#("Value", encode_attribute_value_union(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_expected_attribute_value_struct_top(
  input: ExpectedAttributeValue,
) -> json.Json {
  let pairs = []
  let pairs = case input.attribute_value_list {
    option.Some(v) -> [
      #(
        "AttributeValueList",
        fn(xs) { json.array(xs, encode_attribute_value_union) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.comparison_operator {
    option.Some(v) -> [
      #("ComparisonOperator", encode_comparison_operator_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.exists {
    option.Some(v) -> [#("Exists", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.value {
    option.Some(v) -> [#("Value", encode_attribute_value_union(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_expected_attribute_value_struct() -> decode.Decoder(
  ExpectedAttributeValue,
) {
  use <- decode.recursive
  use attribute_value_list <- decode.optional_field(
    "AttributeValueList",
    option.None,
    decode.optional(decode.list(decode_attribute_value_union())),
  )
  use comparison_operator <- decode.optional_field(
    "ComparisonOperator",
    option.None,
    decode.optional(decode_comparison_operator_enum()),
  )
  use exists <- decode.optional_field(
    "Exists",
    option.None,
    decode.optional(decode.bool),
  )
  use value <- decode.optional_field(
    "Value",
    option.None,
    decode.optional(decode_attribute_value_union()),
  )
  decode.success(ExpectedAttributeValue(
    attribute_value_list: attribute_value_list,
    comparison_operator: comparison_operator,
    exists: exists,
    value: value,
  ))
}

pub type ComparisonOperator {
  ComparisonOperatorBeginsWith
  ComparisonOperatorBetween
  ComparisonOperatorContains
  ComparisonOperatorEq
  ComparisonOperatorGe
  ComparisonOperatorGt
  ComparisonOperatorIn
  ComparisonOperatorLe
  ComparisonOperatorLt
  ComparisonOperatorNe
  ComparisonOperatorNotContains
  ComparisonOperatorNotNull
  ComparisonOperatorNull
}

pub fn encode_comparison_operator_enum(v: ComparisonOperator) -> json.Json {
  case v {
    ComparisonOperatorBeginsWith -> json.string("BEGINS_WITH")
    ComparisonOperatorBetween -> json.string("BETWEEN")
    ComparisonOperatorContains -> json.string("CONTAINS")
    ComparisonOperatorEq -> json.string("EQ")
    ComparisonOperatorGe -> json.string("GE")
    ComparisonOperatorGt -> json.string("GT")
    ComparisonOperatorIn -> json.string("IN")
    ComparisonOperatorLe -> json.string("LE")
    ComparisonOperatorLt -> json.string("LT")
    ComparisonOperatorNe -> json.string("NE")
    ComparisonOperatorNotContains -> json.string("NOT_CONTAINS")
    ComparisonOperatorNotNull -> json.string("NOT_NULL")
    ComparisonOperatorNull -> json.string("NULL")
  }
}

pub fn decode_comparison_operator_enum() -> decode.Decoder(ComparisonOperator) {
  decode.then(decode.string, fn(s) {
    case s {
      "BEGINS_WITH" -> decode.success(ComparisonOperatorBeginsWith)
      "BETWEEN" -> decode.success(ComparisonOperatorBetween)
      "CONTAINS" -> decode.success(ComparisonOperatorContains)
      "EQ" -> decode.success(ComparisonOperatorEq)
      "GE" -> decode.success(ComparisonOperatorGe)
      "GT" -> decode.success(ComparisonOperatorGt)
      "IN" -> decode.success(ComparisonOperatorIn)
      "LE" -> decode.success(ComparisonOperatorLe)
      "LT" -> decode.success(ComparisonOperatorLt)
      "NE" -> decode.success(ComparisonOperatorNe)
      "NOT_CONTAINS" -> decode.success(ComparisonOperatorNotContains)
      "NOT_NULL" -> decode.success(ComparisonOperatorNotNull)
      "NULL" -> decode.success(ComparisonOperatorNull)
      _ -> decode.failure(ComparisonOperatorBeginsWith, "unknown enum value")
    }
  })
}

pub type ReturnValue {
  ReturnValueAllNew
  ReturnValueAllOld
  ReturnValueNone
  ReturnValueUpdatedNew
  ReturnValueUpdatedOld
}

pub fn encode_return_value_enum(v: ReturnValue) -> json.Json {
  case v {
    ReturnValueAllNew -> json.string("ALL_NEW")
    ReturnValueAllOld -> json.string("ALL_OLD")
    ReturnValueNone -> json.string("NONE")
    ReturnValueUpdatedNew -> json.string("UPDATED_NEW")
    ReturnValueUpdatedOld -> json.string("UPDATED_OLD")
  }
}

pub fn decode_return_value_enum() -> decode.Decoder(ReturnValue) {
  decode.then(decode.string, fn(s) {
    case s {
      "ALL_NEW" -> decode.success(ReturnValueAllNew)
      "ALL_OLD" -> decode.success(ReturnValueAllOld)
      "NONE" -> decode.success(ReturnValueNone)
      "UPDATED_NEW" -> decode.success(ReturnValueUpdatedNew)
      "UPDATED_OLD" -> decode.success(ReturnValueUpdatedOld)
      _ -> decode.failure(ReturnValueAllNew, "unknown enum value")
    }
  })
}

pub type DeleteItemOutput {
  DeleteItemOutput(
    attributes: option.Option(dict.Dict(String, AttributeValue)),
    consumed_capacity: option.Option(ConsumedCapacity),
    item_collection_metrics: option.Option(ItemCollectionMetrics),
  )
}

pub fn delete_item_output_default() -> DeleteItemOutput {
  DeleteItemOutput(
    attributes: option.None,
    consumed_capacity: option.None,
    item_collection_metrics: option.None,
  )
}

pub fn encode_delete_item_output_struct(input: DeleteItemOutput) -> json.Json {
  let pairs = []
  let pairs = case input.attributes {
    option.Some(v) -> [
      #(
        "Attributes",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.consumed_capacity {
    option.Some(v) -> [
      #("ConsumedCapacity", encode_consumed_capacity_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.item_collection_metrics {
    option.Some(v) -> [
      #("ItemCollectionMetrics", encode_item_collection_metrics_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_delete_item_output_struct_top(
  input: DeleteItemOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.attributes {
    option.Some(v) -> [
      #(
        "Attributes",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.consumed_capacity {
    option.Some(v) -> [
      #("ConsumedCapacity", encode_consumed_capacity_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.item_collection_metrics {
    option.Some(v) -> [
      #("ItemCollectionMetrics", encode_item_collection_metrics_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_delete_item_output_struct() -> decode.Decoder(DeleteItemOutput) {
  use <- decode.recursive
  use attributes <- decode.optional_field(
    "Attributes",
    option.None,
    decode.optional(decode.dict(decode.string, decode_attribute_value_union())),
  )
  use consumed_capacity <- decode.optional_field(
    "ConsumedCapacity",
    option.None,
    decode.optional(decode_consumed_capacity_struct()),
  )
  use item_collection_metrics <- decode.optional_field(
    "ItemCollectionMetrics",
    option.None,
    decode.optional(decode_item_collection_metrics_struct()),
  )
  decode.success(DeleteItemOutput(
    attributes: attributes,
    consumed_capacity: consumed_capacity,
    item_collection_metrics: item_collection_metrics,
  ))
}

pub type ConditionalCheckFailedException {
  ConditionalCheckFailedException(
    item: option.Option(dict.Dict(String, AttributeValue)),
    message: option.Option(String),
  )
}

pub fn conditional_check_failed_exception_default() -> ConditionalCheckFailedException {
  ConditionalCheckFailedException(item: option.None, message: option.None)
}

pub fn encode_conditional_check_failed_exception_struct(
  input: ConditionalCheckFailedException,
) -> json.Json {
  let pairs = []
  let pairs = case input.item {
    option.Some(v) -> [
      #(
        "Item",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_conditional_check_failed_exception_struct_top(
  input: ConditionalCheckFailedException,
) -> json.Json {
  let pairs = []
  let pairs = case input.item {
    option.Some(v) -> [
      #(
        "Item",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_conditional_check_failed_exception_struct() -> decode.Decoder(
  ConditionalCheckFailedException,
) {
  use <- decode.recursive
  use item <- decode.optional_field(
    "Item",
    option.None,
    decode.optional(decode.dict(decode.string, decode_attribute_value_union())),
  )
  use message <- decode.optional_field(
    "message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ConditionalCheckFailedException(item: item, message: message))
}

pub type TransactionConflictException {
  TransactionConflictException(message: option.Option(String))
}

pub fn transaction_conflict_exception_default() -> TransactionConflictException {
  TransactionConflictException(message: option.None)
}

pub fn encode_transaction_conflict_exception_struct(
  input: TransactionConflictException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_transaction_conflict_exception_struct_top(
  input: TransactionConflictException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_transaction_conflict_exception_struct() -> decode.Decoder(
  TransactionConflictException,
) {
  use <- decode.recursive
  use message <- decode.optional_field(
    "message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(TransactionConflictException(message: message))
}

pub type DeleteResourcePolicyInput {
  DeleteResourcePolicyInput(
    expected_revision_id: option.Option(String),
    resource_arn: option.Option(String),
  )
}

pub fn delete_resource_policy_input_default() -> DeleteResourcePolicyInput {
  DeleteResourcePolicyInput(
    expected_revision_id: option.None,
    resource_arn: option.None,
  )
}

pub fn encode_delete_resource_policy_input_struct(
  input: DeleteResourcePolicyInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.expected_revision_id {
    option.Some(v) -> [#("ExpectedRevisionId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.resource_arn {
    option.Some(v) -> [#("ResourceArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_delete_resource_policy_input_struct_top(
  input: DeleteResourcePolicyInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.expected_revision_id {
    option.Some(v) -> [#("ExpectedRevisionId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.resource_arn {
    option.Some(v) -> [#("ResourceArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_delete_resource_policy_input_struct() -> decode.Decoder(
  DeleteResourcePolicyInput,
) {
  use <- decode.recursive
  use expected_revision_id <- decode.optional_field(
    "ExpectedRevisionId",
    option.None,
    decode.optional(decode.string),
  )
  use resource_arn <- decode.optional_field(
    "ResourceArn",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteResourcePolicyInput(
    expected_revision_id: expected_revision_id,
    resource_arn: resource_arn,
  ))
}

pub type DeleteResourcePolicyOutput {
  DeleteResourcePolicyOutput(revision_id: option.Option(String))
}

pub fn delete_resource_policy_output_default() -> DeleteResourcePolicyOutput {
  DeleteResourcePolicyOutput(revision_id: option.None)
}

pub fn encode_delete_resource_policy_output_struct(
  input: DeleteResourcePolicyOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.revision_id {
    option.Some(v) -> [#("RevisionId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_delete_resource_policy_output_struct_top(
  input: DeleteResourcePolicyOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.revision_id {
    option.Some(v) -> [#("RevisionId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_delete_resource_policy_output_struct() -> decode.Decoder(
  DeleteResourcePolicyOutput,
) {
  use <- decode.recursive
  use revision_id <- decode.optional_field(
    "RevisionId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteResourcePolicyOutput(revision_id: revision_id))
}

pub type PolicyNotFoundException {
  PolicyNotFoundException(message: option.Option(String))
}

pub fn policy_not_found_exception_default() -> PolicyNotFoundException {
  PolicyNotFoundException(message: option.None)
}

pub fn encode_policy_not_found_exception_struct(
  input: PolicyNotFoundException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_policy_not_found_exception_struct_top(
  input: PolicyNotFoundException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_policy_not_found_exception_struct() -> decode.Decoder(
  PolicyNotFoundException,
) {
  use <- decode.recursive
  use message <- decode.optional_field(
    "message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(PolicyNotFoundException(message: message))
}

pub type DeleteTableInput {
  DeleteTableInput(table_name: option.Option(String))
}

pub fn delete_table_input_default() -> DeleteTableInput {
  DeleteTableInput(table_name: option.None)
}

pub fn encode_delete_table_input_struct(input: DeleteTableInput) -> json.Json {
  let pairs = []
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_delete_table_input_struct_top(
  input: DeleteTableInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_delete_table_input_struct() -> decode.Decoder(DeleteTableInput) {
  use <- decode.recursive
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteTableInput(table_name: table_name))
}

pub type DeleteTableOutput {
  DeleteTableOutput(table_description: option.Option(TableDescription))
}

pub fn delete_table_output_default() -> DeleteTableOutput {
  DeleteTableOutput(table_description: option.None)
}

pub fn encode_delete_table_output_struct(
  input: DeleteTableOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.table_description {
    option.Some(v) -> [
      #("TableDescription", encode_table_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_delete_table_output_struct_top(
  input: DeleteTableOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.table_description {
    option.Some(v) -> [
      #("TableDescription", encode_table_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_delete_table_output_struct() -> decode.Decoder(DeleteTableOutput) {
  use <- decode.recursive
  use table_description <- decode.optional_field(
    "TableDescription",
    option.None,
    decode.optional(decode_table_description_struct()),
  )
  decode.success(DeleteTableOutput(table_description: table_description))
}

pub type DescribeBackupInput {
  DescribeBackupInput(backup_arn: option.Option(String))
}

pub fn describe_backup_input_default() -> DescribeBackupInput {
  DescribeBackupInput(backup_arn: option.None)
}

pub fn encode_describe_backup_input_struct(
  input: DescribeBackupInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.backup_arn {
    option.Some(v) -> [#("BackupArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_describe_backup_input_struct_top(
  input: DescribeBackupInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.backup_arn {
    option.Some(v) -> [#("BackupArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_describe_backup_input_struct() -> decode.Decoder(
  DescribeBackupInput,
) {
  use <- decode.recursive
  use backup_arn <- decode.optional_field(
    "BackupArn",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DescribeBackupInput(backup_arn: backup_arn))
}

pub type DescribeBackupOutput {
  DescribeBackupOutput(backup_description: option.Option(BackupDescription))
}

pub fn describe_backup_output_default() -> DescribeBackupOutput {
  DescribeBackupOutput(backup_description: option.None)
}

pub fn encode_describe_backup_output_struct(
  input: DescribeBackupOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.backup_description {
    option.Some(v) -> [
      #("BackupDescription", encode_backup_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_describe_backup_output_struct_top(
  input: DescribeBackupOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.backup_description {
    option.Some(v) -> [
      #("BackupDescription", encode_backup_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_describe_backup_output_struct() -> decode.Decoder(
  DescribeBackupOutput,
) {
  use <- decode.recursive
  use backup_description <- decode.optional_field(
    "BackupDescription",
    option.None,
    decode.optional(decode_backup_description_struct()),
  )
  decode.success(DescribeBackupOutput(backup_description: backup_description))
}

pub type DescribeContinuousBackupsInput {
  DescribeContinuousBackupsInput(table_name: option.Option(String))
}

pub fn describe_continuous_backups_input_default() -> DescribeContinuousBackupsInput {
  DescribeContinuousBackupsInput(table_name: option.None)
}

pub fn encode_describe_continuous_backups_input_struct(
  input: DescribeContinuousBackupsInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_describe_continuous_backups_input_struct_top(
  input: DescribeContinuousBackupsInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_describe_continuous_backups_input_struct() -> decode.Decoder(
  DescribeContinuousBackupsInput,
) {
  use <- decode.recursive
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DescribeContinuousBackupsInput(table_name: table_name))
}

pub type DescribeContinuousBackupsOutput {
  DescribeContinuousBackupsOutput(
    continuous_backups_description: option.Option(ContinuousBackupsDescription),
  )
}

pub fn describe_continuous_backups_output_default() -> DescribeContinuousBackupsOutput {
  DescribeContinuousBackupsOutput(continuous_backups_description: option.None)
}

pub fn encode_describe_continuous_backups_output_struct(
  input: DescribeContinuousBackupsOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.continuous_backups_description {
    option.Some(v) -> [
      #(
        "ContinuousBackupsDescription",
        encode_continuous_backups_description_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_describe_continuous_backups_output_struct_top(
  input: DescribeContinuousBackupsOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.continuous_backups_description {
    option.Some(v) -> [
      #(
        "ContinuousBackupsDescription",
        encode_continuous_backups_description_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_describe_continuous_backups_output_struct() -> decode.Decoder(
  DescribeContinuousBackupsOutput,
) {
  use <- decode.recursive
  use continuous_backups_description <- decode.optional_field(
    "ContinuousBackupsDescription",
    option.None,
    decode.optional(decode_continuous_backups_description_struct()),
  )
  decode.success(DescribeContinuousBackupsOutput(
    continuous_backups_description: continuous_backups_description,
  ))
}

pub type ContinuousBackupsDescription {
  ContinuousBackupsDescription(
    continuous_backups_status: option.Option(ContinuousBackupsStatus),
    point_in_time_recovery_description: option.Option(
      PointInTimeRecoveryDescription,
    ),
  )
}

pub fn continuous_backups_description_default() -> ContinuousBackupsDescription {
  ContinuousBackupsDescription(
    continuous_backups_status: option.None,
    point_in_time_recovery_description: option.None,
  )
}

pub fn encode_continuous_backups_description_struct(
  input: ContinuousBackupsDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.continuous_backups_status {
    option.Some(v) -> [
      #("ContinuousBackupsStatus", encode_continuous_backups_status_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.point_in_time_recovery_description {
    option.Some(v) -> [
      #(
        "PointInTimeRecoveryDescription",
        encode_point_in_time_recovery_description_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_continuous_backups_description_struct_top(
  input: ContinuousBackupsDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.continuous_backups_status {
    option.Some(v) -> [
      #("ContinuousBackupsStatus", encode_continuous_backups_status_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.point_in_time_recovery_description {
    option.Some(v) -> [
      #(
        "PointInTimeRecoveryDescription",
        encode_point_in_time_recovery_description_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_continuous_backups_description_struct() -> decode.Decoder(
  ContinuousBackupsDescription,
) {
  use <- decode.recursive
  use continuous_backups_status <- decode.optional_field(
    "ContinuousBackupsStatus",
    option.None,
    decode.optional(decode_continuous_backups_status_enum()),
  )
  use point_in_time_recovery_description <- decode.optional_field(
    "PointInTimeRecoveryDescription",
    option.None,
    decode.optional(decode_point_in_time_recovery_description_struct()),
  )
  decode.success(ContinuousBackupsDescription(
    continuous_backups_status: continuous_backups_status,
    point_in_time_recovery_description: point_in_time_recovery_description,
  ))
}

pub type ContinuousBackupsStatus {
  ContinuousBackupsStatusDisabled
  ContinuousBackupsStatusEnabled
}

pub fn encode_continuous_backups_status_enum(
  v: ContinuousBackupsStatus,
) -> json.Json {
  case v {
    ContinuousBackupsStatusDisabled -> json.string("DISABLED")
    ContinuousBackupsStatusEnabled -> json.string("ENABLED")
  }
}

pub fn decode_continuous_backups_status_enum() -> decode.Decoder(
  ContinuousBackupsStatus,
) {
  decode.then(decode.string, fn(s) {
    case s {
      "DISABLED" -> decode.success(ContinuousBackupsStatusDisabled)
      "ENABLED" -> decode.success(ContinuousBackupsStatusEnabled)
      _ -> decode.failure(ContinuousBackupsStatusDisabled, "unknown enum value")
    }
  })
}

pub type PointInTimeRecoveryDescription {
  PointInTimeRecoveryDescription(
    earliest_restorable_date_time: option.Option(json_timestamp.Timestamp),
    latest_restorable_date_time: option.Option(json_timestamp.Timestamp),
    point_in_time_recovery_status: option.Option(PointInTimeRecoveryStatus),
    recovery_period_in_days: option.Option(Int),
  )
}

pub fn point_in_time_recovery_description_default() -> PointInTimeRecoveryDescription {
  PointInTimeRecoveryDescription(
    earliest_restorable_date_time: option.None,
    latest_restorable_date_time: option.None,
    point_in_time_recovery_status: option.None,
    recovery_period_in_days: option.None,
  )
}

pub fn encode_point_in_time_recovery_description_struct(
  input: PointInTimeRecoveryDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.earliest_restorable_date_time {
    option.Some(v) -> [
      #("EarliestRestorableDateTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.latest_restorable_date_time {
    option.Some(v) -> [
      #("LatestRestorableDateTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.point_in_time_recovery_status {
    option.Some(v) -> [
      #(
        "PointInTimeRecoveryStatus",
        encode_point_in_time_recovery_status_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.recovery_period_in_days {
    option.Some(v) -> [#("RecoveryPeriodInDays", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_point_in_time_recovery_description_struct_top(
  input: PointInTimeRecoveryDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.earliest_restorable_date_time {
    option.Some(v) -> [
      #("EarliestRestorableDateTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.latest_restorable_date_time {
    option.Some(v) -> [
      #("LatestRestorableDateTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.point_in_time_recovery_status {
    option.Some(v) -> [
      #(
        "PointInTimeRecoveryStatus",
        encode_point_in_time_recovery_status_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.recovery_period_in_days {
    option.Some(v) -> [#("RecoveryPeriodInDays", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_point_in_time_recovery_description_struct() -> decode.Decoder(
  PointInTimeRecoveryDescription,
) {
  use <- decode.recursive
  use earliest_restorable_date_time <- decode.optional_field(
    "EarliestRestorableDateTime",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use latest_restorable_date_time <- decode.optional_field(
    "LatestRestorableDateTime",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use point_in_time_recovery_status <- decode.optional_field(
    "PointInTimeRecoveryStatus",
    option.None,
    decode.optional(decode_point_in_time_recovery_status_enum()),
  )
  use recovery_period_in_days <- decode.optional_field(
    "RecoveryPeriodInDays",
    option.None,
    decode.optional(decode.int),
  )
  decode.success(PointInTimeRecoveryDescription(
    earliest_restorable_date_time: earliest_restorable_date_time,
    latest_restorable_date_time: latest_restorable_date_time,
    point_in_time_recovery_status: point_in_time_recovery_status,
    recovery_period_in_days: recovery_period_in_days,
  ))
}

pub type PointInTimeRecoveryStatus {
  PointInTimeRecoveryStatusDisabled
  PointInTimeRecoveryStatusEnabled
}

pub fn encode_point_in_time_recovery_status_enum(
  v: PointInTimeRecoveryStatus,
) -> json.Json {
  case v {
    PointInTimeRecoveryStatusDisabled -> json.string("DISABLED")
    PointInTimeRecoveryStatusEnabled -> json.string("ENABLED")
  }
}

pub fn decode_point_in_time_recovery_status_enum() -> decode.Decoder(
  PointInTimeRecoveryStatus,
) {
  decode.then(decode.string, fn(s) {
    case s {
      "DISABLED" -> decode.success(PointInTimeRecoveryStatusDisabled)
      "ENABLED" -> decode.success(PointInTimeRecoveryStatusEnabled)
      _ ->
        decode.failure(PointInTimeRecoveryStatusDisabled, "unknown enum value")
    }
  })
}

pub type DescribeContributorInsightsInput {
  DescribeContributorInsightsInput(
    index_name: option.Option(String),
    table_name: option.Option(String),
  )
}

pub fn describe_contributor_insights_input_default() -> DescribeContributorInsightsInput {
  DescribeContributorInsightsInput(
    index_name: option.None,
    table_name: option.None,
  )
}

pub fn encode_describe_contributor_insights_input_struct(
  input: DescribeContributorInsightsInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_describe_contributor_insights_input_struct_top(
  input: DescribeContributorInsightsInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_describe_contributor_insights_input_struct() -> decode.Decoder(
  DescribeContributorInsightsInput,
) {
  use <- decode.recursive
  use index_name <- decode.optional_field(
    "IndexName",
    option.None,
    decode.optional(decode.string),
  )
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DescribeContributorInsightsInput(
    index_name: index_name,
    table_name: table_name,
  ))
}

pub type DescribeContributorInsightsOutput {
  DescribeContributorInsightsOutput(
    contributor_insights_mode: option.Option(ContributorInsightsMode),
    contributor_insights_rule_list: option.Option(List(String)),
    contributor_insights_status: option.Option(ContributorInsightsStatus),
    failure_exception: option.Option(FailureException),
    index_name: option.Option(String),
    last_update_date_time: option.Option(json_timestamp.Timestamp),
    table_name: option.Option(String),
  )
}

pub fn describe_contributor_insights_output_default() -> DescribeContributorInsightsOutput {
  DescribeContributorInsightsOutput(
    contributor_insights_mode: option.None,
    contributor_insights_rule_list: option.None,
    contributor_insights_status: option.None,
    failure_exception: option.None,
    index_name: option.None,
    last_update_date_time: option.None,
    table_name: option.None,
  )
}

pub fn encode_describe_contributor_insights_output_struct(
  input: DescribeContributorInsightsOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.contributor_insights_mode {
    option.Some(v) -> [
      #("ContributorInsightsMode", encode_contributor_insights_mode_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.contributor_insights_rule_list {
    option.Some(v) -> [
      #(
        "ContributorInsightsRuleList",
        fn(xs) { json.array(xs, json.string) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.contributor_insights_status {
    option.Some(v) -> [
      #("ContributorInsightsStatus", encode_contributor_insights_status_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.failure_exception {
    option.Some(v) -> [
      #("FailureException", encode_failure_exception_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.last_update_date_time {
    option.Some(v) -> [
      #("LastUpdateDateTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_describe_contributor_insights_output_struct_top(
  input: DescribeContributorInsightsOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.contributor_insights_mode {
    option.Some(v) -> [
      #("ContributorInsightsMode", encode_contributor_insights_mode_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.contributor_insights_rule_list {
    option.Some(v) -> [
      #(
        "ContributorInsightsRuleList",
        fn(xs) { json.array(xs, json.string) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.contributor_insights_status {
    option.Some(v) -> [
      #("ContributorInsightsStatus", encode_contributor_insights_status_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.failure_exception {
    option.Some(v) -> [
      #("FailureException", encode_failure_exception_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.last_update_date_time {
    option.Some(v) -> [
      #("LastUpdateDateTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_describe_contributor_insights_output_struct() -> decode.Decoder(
  DescribeContributorInsightsOutput,
) {
  use <- decode.recursive
  use contributor_insights_mode <- decode.optional_field(
    "ContributorInsightsMode",
    option.None,
    decode.optional(decode_contributor_insights_mode_enum()),
  )
  use contributor_insights_rule_list <- decode.optional_field(
    "ContributorInsightsRuleList",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  use contributor_insights_status <- decode.optional_field(
    "ContributorInsightsStatus",
    option.None,
    decode.optional(decode_contributor_insights_status_enum()),
  )
  use failure_exception <- decode.optional_field(
    "FailureException",
    option.None,
    decode.optional(decode_failure_exception_struct()),
  )
  use index_name <- decode.optional_field(
    "IndexName",
    option.None,
    decode.optional(decode.string),
  )
  use last_update_date_time <- decode.optional_field(
    "LastUpdateDateTime",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DescribeContributorInsightsOutput(
    contributor_insights_mode: contributor_insights_mode,
    contributor_insights_rule_list: contributor_insights_rule_list,
    contributor_insights_status: contributor_insights_status,
    failure_exception: failure_exception,
    index_name: index_name,
    last_update_date_time: last_update_date_time,
    table_name: table_name,
  ))
}

pub type ContributorInsightsMode {
  ContributorInsightsModeAccessedAndThrottledKeys
  ContributorInsightsModeThrottledKeys
}

pub fn encode_contributor_insights_mode_enum(
  v: ContributorInsightsMode,
) -> json.Json {
  case v {
    ContributorInsightsModeAccessedAndThrottledKeys ->
      json.string("ACCESSED_AND_THROTTLED_KEYS")
    ContributorInsightsModeThrottledKeys -> json.string("THROTTLED_KEYS")
  }
}

pub fn decode_contributor_insights_mode_enum() -> decode.Decoder(
  ContributorInsightsMode,
) {
  decode.then(decode.string, fn(s) {
    case s {
      "ACCESSED_AND_THROTTLED_KEYS" ->
        decode.success(ContributorInsightsModeAccessedAndThrottledKeys)
      "THROTTLED_KEYS" -> decode.success(ContributorInsightsModeThrottledKeys)
      _ ->
        decode.failure(
          ContributorInsightsModeAccessedAndThrottledKeys,
          "unknown enum value",
        )
    }
  })
}

pub type ContributorInsightsStatus {
  ContributorInsightsStatusDisabled
  ContributorInsightsStatusDisabling
  ContributorInsightsStatusEnabled
  ContributorInsightsStatusEnabling
  ContributorInsightsStatusFailed
}

pub fn encode_contributor_insights_status_enum(
  v: ContributorInsightsStatus,
) -> json.Json {
  case v {
    ContributorInsightsStatusDisabled -> json.string("DISABLED")
    ContributorInsightsStatusDisabling -> json.string("DISABLING")
    ContributorInsightsStatusEnabled -> json.string("ENABLED")
    ContributorInsightsStatusEnabling -> json.string("ENABLING")
    ContributorInsightsStatusFailed -> json.string("FAILED")
  }
}

pub fn decode_contributor_insights_status_enum() -> decode.Decoder(
  ContributorInsightsStatus,
) {
  decode.then(decode.string, fn(s) {
    case s {
      "DISABLED" -> decode.success(ContributorInsightsStatusDisabled)
      "DISABLING" -> decode.success(ContributorInsightsStatusDisabling)
      "ENABLED" -> decode.success(ContributorInsightsStatusEnabled)
      "ENABLING" -> decode.success(ContributorInsightsStatusEnabling)
      "FAILED" -> decode.success(ContributorInsightsStatusFailed)
      _ ->
        decode.failure(ContributorInsightsStatusDisabled, "unknown enum value")
    }
  })
}

pub type FailureException {
  FailureException(
    exception_description: option.Option(String),
    exception_name: option.Option(String),
  )
}

pub fn failure_exception_default() -> FailureException {
  FailureException(
    exception_description: option.None,
    exception_name: option.None,
  )
}

pub fn encode_failure_exception_struct(input: FailureException) -> json.Json {
  let pairs = []
  let pairs = case input.exception_description {
    option.Some(v) -> [#("ExceptionDescription", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.exception_name {
    option.Some(v) -> [#("ExceptionName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_failure_exception_struct_top(
  input: FailureException,
) -> json.Json {
  let pairs = []
  let pairs = case input.exception_description {
    option.Some(v) -> [#("ExceptionDescription", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.exception_name {
    option.Some(v) -> [#("ExceptionName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_failure_exception_struct() -> decode.Decoder(FailureException) {
  use <- decode.recursive
  use exception_description <- decode.optional_field(
    "ExceptionDescription",
    option.None,
    decode.optional(decode.string),
  )
  use exception_name <- decode.optional_field(
    "ExceptionName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(FailureException(
    exception_description: exception_description,
    exception_name: exception_name,
  ))
}

pub type DescribeEndpointsRequest {
  DescribeEndpointsRequest
}

pub fn describe_endpoints_request_default() -> DescribeEndpointsRequest {
  DescribeEndpointsRequest
}

pub fn encode_describe_endpoints_request_struct(
  _v: DescribeEndpointsRequest,
) -> json.Json {
  json.object([])
}

pub fn encode_describe_endpoints_request_struct_top(
  _v: DescribeEndpointsRequest,
) -> json.Json {
  json.object([])
}

pub fn decode_describe_endpoints_request_struct() -> decode.Decoder(
  DescribeEndpointsRequest,
) {
  decode.success(DescribeEndpointsRequest)
}

pub type DescribeEndpointsResponse {
  DescribeEndpointsResponse(endpoints: option.Option(List(Endpoint)))
}

pub fn describe_endpoints_response_default() -> DescribeEndpointsResponse {
  DescribeEndpointsResponse(endpoints: option.None)
}

pub fn encode_describe_endpoints_response_struct(
  input: DescribeEndpointsResponse,
) -> json.Json {
  let pairs = []
  let pairs = case input.endpoints {
    option.Some(v) -> [
      #("Endpoints", fn(xs) { json.array(xs, encode_endpoint_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_describe_endpoints_response_struct_top(
  input: DescribeEndpointsResponse,
) -> json.Json {
  let pairs = []
  let pairs = case input.endpoints {
    option.Some(v) -> [
      #("Endpoints", fn(xs) { json.array(xs, encode_endpoint_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_describe_endpoints_response_struct() -> decode.Decoder(
  DescribeEndpointsResponse,
) {
  use <- decode.recursive
  use endpoints <- decode.optional_field(
    "Endpoints",
    option.None,
    decode.optional(decode.list(decode_endpoint_struct())),
  )
  decode.success(DescribeEndpointsResponse(endpoints: endpoints))
}

pub type Endpoint {
  Endpoint(
    address: option.Option(String),
    cache_period_in_minutes: option.Option(Int),
  )
}

pub fn endpoint_default() -> Endpoint {
  Endpoint(address: option.None, cache_period_in_minutes: option.None)
}

pub fn encode_endpoint_struct(input: Endpoint) -> json.Json {
  let pairs = []
  let pairs = case input.address {
    option.Some(v) -> [#("Address", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.cache_period_in_minutes {
    option.Some(v) -> [#("CachePeriodInMinutes", json.int(v)), ..pairs]
    option.None -> [#("CachePeriodInMinutes", json.int(0)), ..pairs]
  }
  json.object(pairs)
}

pub fn encode_endpoint_struct_top(input: Endpoint) -> json.Json {
  let pairs = []
  let pairs = case input.address {
    option.Some(v) -> [#("Address", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.cache_period_in_minutes {
    option.Some(v) -> [#("CachePeriodInMinutes", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_endpoint_struct() -> decode.Decoder(Endpoint) {
  use <- decode.recursive
  use address <- decode.optional_field(
    "Address",
    option.None,
    decode.optional(decode.string),
  )
  use cache_period_in_minutes <- decode.optional_field(
    "CachePeriodInMinutes",
    option.None,
    decode.optional(decode.int),
  )
  decode.success(Endpoint(
    address: address,
    cache_period_in_minutes: cache_period_in_minutes,
  ))
}

pub type DescribeExportInput {
  DescribeExportInput(export_arn: option.Option(String))
}

pub fn describe_export_input_default() -> DescribeExportInput {
  DescribeExportInput(export_arn: option.None)
}

pub fn encode_describe_export_input_struct(
  input: DescribeExportInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.export_arn {
    option.Some(v) -> [#("ExportArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_describe_export_input_struct_top(
  input: DescribeExportInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.export_arn {
    option.Some(v) -> [#("ExportArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_describe_export_input_struct() -> decode.Decoder(
  DescribeExportInput,
) {
  use <- decode.recursive
  use export_arn <- decode.optional_field(
    "ExportArn",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DescribeExportInput(export_arn: export_arn))
}

pub type DescribeExportOutput {
  DescribeExportOutput(export_description: option.Option(ExportDescription))
}

pub fn describe_export_output_default() -> DescribeExportOutput {
  DescribeExportOutput(export_description: option.None)
}

pub fn encode_describe_export_output_struct(
  input: DescribeExportOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.export_description {
    option.Some(v) -> [
      #("ExportDescription", encode_export_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_describe_export_output_struct_top(
  input: DescribeExportOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.export_description {
    option.Some(v) -> [
      #("ExportDescription", encode_export_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_describe_export_output_struct() -> decode.Decoder(
  DescribeExportOutput,
) {
  use <- decode.recursive
  use export_description <- decode.optional_field(
    "ExportDescription",
    option.None,
    decode.optional(decode_export_description_struct()),
  )
  decode.success(DescribeExportOutput(export_description: export_description))
}

pub type ExportDescription {
  ExportDescription(
    billed_size_bytes: option.Option(Int),
    client_token: option.Option(String),
    end_time: option.Option(json_timestamp.Timestamp),
    export_arn: option.Option(String),
    export_format: option.Option(ExportFormat),
    export_manifest: option.Option(String),
    export_status: option.Option(ExportStatus),
    export_time: option.Option(json_timestamp.Timestamp),
    export_type: option.Option(ExportType),
    failure_code: option.Option(String),
    failure_message: option.Option(String),
    incremental_export_specification: option.Option(
      IncrementalExportSpecification,
    ),
    item_count: option.Option(Int),
    s3_bucket: option.Option(String),
    s3_bucket_owner: option.Option(String),
    s3_prefix: option.Option(String),
    s3_sse_algorithm: option.Option(S3SseAlgorithm),
    s3_sse_kms_key_id: option.Option(String),
    start_time: option.Option(json_timestamp.Timestamp),
    table_arn: option.Option(String),
    table_id: option.Option(String),
  )
}

pub fn export_description_default() -> ExportDescription {
  ExportDescription(
    billed_size_bytes: option.None,
    client_token: option.None,
    end_time: option.None,
    export_arn: option.None,
    export_format: option.None,
    export_manifest: option.None,
    export_status: option.None,
    export_time: option.None,
    export_type: option.None,
    failure_code: option.None,
    failure_message: option.None,
    incremental_export_specification: option.None,
    item_count: option.None,
    s3_bucket: option.None,
    s3_bucket_owner: option.None,
    s3_prefix: option.None,
    s3_sse_algorithm: option.None,
    s3_sse_kms_key_id: option.None,
    start_time: option.None,
    table_arn: option.None,
    table_id: option.None,
  )
}

pub fn encode_export_description_struct(input: ExportDescription) -> json.Json {
  let pairs = []
  let pairs = case input.billed_size_bytes {
    option.Some(v) -> [#("BilledSizeBytes", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.client_token {
    option.Some(v) -> [#("ClientToken", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.end_time {
    option.Some(v) -> [
      #("EndTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.export_arn {
    option.Some(v) -> [#("ExportArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.export_format {
    option.Some(v) -> [#("ExportFormat", encode_export_format_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.export_manifest {
    option.Some(v) -> [#("ExportManifest", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.export_status {
    option.Some(v) -> [#("ExportStatus", encode_export_status_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.export_time {
    option.Some(v) -> [
      #("ExportTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.export_type {
    option.Some(v) -> [#("ExportType", encode_export_type_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.failure_code {
    option.Some(v) -> [#("FailureCode", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.failure_message {
    option.Some(v) -> [#("FailureMessage", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.incremental_export_specification {
    option.Some(v) -> [
      #(
        "IncrementalExportSpecification",
        encode_incremental_export_specification_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.item_count {
    option.Some(v) -> [#("ItemCount", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.s3_bucket {
    option.Some(v) -> [#("S3Bucket", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.s3_bucket_owner {
    option.Some(v) -> [#("S3BucketOwner", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.s3_prefix {
    option.Some(v) -> [#("S3Prefix", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.s3_sse_algorithm {
    option.Some(v) -> [
      #("S3SseAlgorithm", encode_s3_sse_algorithm_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.s3_sse_kms_key_id {
    option.Some(v) -> [#("S3SseKmsKeyId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.start_time {
    option.Some(v) -> [
      #("StartTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_arn {
    option.Some(v) -> [#("TableArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_id {
    option.Some(v) -> [#("TableId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_export_description_struct_top(
  input: ExportDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.billed_size_bytes {
    option.Some(v) -> [#("BilledSizeBytes", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.client_token {
    option.Some(v) -> [#("ClientToken", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.end_time {
    option.Some(v) -> [
      #("EndTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.export_arn {
    option.Some(v) -> [#("ExportArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.export_format {
    option.Some(v) -> [#("ExportFormat", encode_export_format_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.export_manifest {
    option.Some(v) -> [#("ExportManifest", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.export_status {
    option.Some(v) -> [#("ExportStatus", encode_export_status_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.export_time {
    option.Some(v) -> [
      #("ExportTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.export_type {
    option.Some(v) -> [#("ExportType", encode_export_type_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.failure_code {
    option.Some(v) -> [#("FailureCode", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.failure_message {
    option.Some(v) -> [#("FailureMessage", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.incremental_export_specification {
    option.Some(v) -> [
      #(
        "IncrementalExportSpecification",
        encode_incremental_export_specification_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.item_count {
    option.Some(v) -> [#("ItemCount", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.s3_bucket {
    option.Some(v) -> [#("S3Bucket", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.s3_bucket_owner {
    option.Some(v) -> [#("S3BucketOwner", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.s3_prefix {
    option.Some(v) -> [#("S3Prefix", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.s3_sse_algorithm {
    option.Some(v) -> [
      #("S3SseAlgorithm", encode_s3_sse_algorithm_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.s3_sse_kms_key_id {
    option.Some(v) -> [#("S3SseKmsKeyId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.start_time {
    option.Some(v) -> [
      #("StartTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_arn {
    option.Some(v) -> [#("TableArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_id {
    option.Some(v) -> [#("TableId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_export_description_struct() -> decode.Decoder(ExportDescription) {
  use <- decode.recursive
  use billed_size_bytes <- decode.optional_field(
    "BilledSizeBytes",
    option.None,
    decode.optional(decode.int),
  )
  use client_token <- decode.optional_field(
    "ClientToken",
    option.None,
    decode.optional(decode.string),
  )
  use end_time <- decode.optional_field(
    "EndTime",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use export_arn <- decode.optional_field(
    "ExportArn",
    option.None,
    decode.optional(decode.string),
  )
  use export_format <- decode.optional_field(
    "ExportFormat",
    option.None,
    decode.optional(decode_export_format_enum()),
  )
  use export_manifest <- decode.optional_field(
    "ExportManifest",
    option.None,
    decode.optional(decode.string),
  )
  use export_status <- decode.optional_field(
    "ExportStatus",
    option.None,
    decode.optional(decode_export_status_enum()),
  )
  use export_time <- decode.optional_field(
    "ExportTime",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use export_type <- decode.optional_field(
    "ExportType",
    option.None,
    decode.optional(decode_export_type_enum()),
  )
  use failure_code <- decode.optional_field(
    "FailureCode",
    option.None,
    decode.optional(decode.string),
  )
  use failure_message <- decode.optional_field(
    "FailureMessage",
    option.None,
    decode.optional(decode.string),
  )
  use incremental_export_specification <- decode.optional_field(
    "IncrementalExportSpecification",
    option.None,
    decode.optional(decode_incremental_export_specification_struct()),
  )
  use item_count <- decode.optional_field(
    "ItemCount",
    option.None,
    decode.optional(decode.int),
  )
  use s3_bucket <- decode.optional_field(
    "S3Bucket",
    option.None,
    decode.optional(decode.string),
  )
  use s3_bucket_owner <- decode.optional_field(
    "S3BucketOwner",
    option.None,
    decode.optional(decode.string),
  )
  use s3_prefix <- decode.optional_field(
    "S3Prefix",
    option.None,
    decode.optional(decode.string),
  )
  use s3_sse_algorithm <- decode.optional_field(
    "S3SseAlgorithm",
    option.None,
    decode.optional(decode_s3_sse_algorithm_enum()),
  )
  use s3_sse_kms_key_id <- decode.optional_field(
    "S3SseKmsKeyId",
    option.None,
    decode.optional(decode.string),
  )
  use start_time <- decode.optional_field(
    "StartTime",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use table_arn <- decode.optional_field(
    "TableArn",
    option.None,
    decode.optional(decode.string),
  )
  use table_id <- decode.optional_field(
    "TableId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ExportDescription(
    billed_size_bytes: billed_size_bytes,
    client_token: client_token,
    end_time: end_time,
    export_arn: export_arn,
    export_format: export_format,
    export_manifest: export_manifest,
    export_status: export_status,
    export_time: export_time,
    export_type: export_type,
    failure_code: failure_code,
    failure_message: failure_message,
    incremental_export_specification: incremental_export_specification,
    item_count: item_count,
    s3_bucket: s3_bucket,
    s3_bucket_owner: s3_bucket_owner,
    s3_prefix: s3_prefix,
    s3_sse_algorithm: s3_sse_algorithm,
    s3_sse_kms_key_id: s3_sse_kms_key_id,
    start_time: start_time,
    table_arn: table_arn,
    table_id: table_id,
  ))
}

pub type ExportFormat {
  ExportFormatDynamodbJson
  ExportFormatIon
}

pub fn encode_export_format_enum(v: ExportFormat) -> json.Json {
  case v {
    ExportFormatDynamodbJson -> json.string("DYNAMODB_JSON")
    ExportFormatIon -> json.string("ION")
  }
}

pub fn decode_export_format_enum() -> decode.Decoder(ExportFormat) {
  decode.then(decode.string, fn(s) {
    case s {
      "DYNAMODB_JSON" -> decode.success(ExportFormatDynamodbJson)
      "ION" -> decode.success(ExportFormatIon)
      _ -> decode.failure(ExportFormatDynamodbJson, "unknown enum value")
    }
  })
}

pub type ExportStatus {
  ExportStatusCompleted
  ExportStatusFailed
  ExportStatusInProgress
}

pub fn encode_export_status_enum(v: ExportStatus) -> json.Json {
  case v {
    ExportStatusCompleted -> json.string("COMPLETED")
    ExportStatusFailed -> json.string("FAILED")
    ExportStatusInProgress -> json.string("IN_PROGRESS")
  }
}

pub fn decode_export_status_enum() -> decode.Decoder(ExportStatus) {
  decode.then(decode.string, fn(s) {
    case s {
      "COMPLETED" -> decode.success(ExportStatusCompleted)
      "FAILED" -> decode.success(ExportStatusFailed)
      "IN_PROGRESS" -> decode.success(ExportStatusInProgress)
      _ -> decode.failure(ExportStatusCompleted, "unknown enum value")
    }
  })
}

pub type ExportType {
  ExportTypeFullExport
  ExportTypeIncrementalExport
}

pub fn encode_export_type_enum(v: ExportType) -> json.Json {
  case v {
    ExportTypeFullExport -> json.string("FULL_EXPORT")
    ExportTypeIncrementalExport -> json.string("INCREMENTAL_EXPORT")
  }
}

pub fn decode_export_type_enum() -> decode.Decoder(ExportType) {
  decode.then(decode.string, fn(s) {
    case s {
      "FULL_EXPORT" -> decode.success(ExportTypeFullExport)
      "INCREMENTAL_EXPORT" -> decode.success(ExportTypeIncrementalExport)
      _ -> decode.failure(ExportTypeFullExport, "unknown enum value")
    }
  })
}

pub type IncrementalExportSpecification {
  IncrementalExportSpecification(
    export_from_time: option.Option(json_timestamp.Timestamp),
    export_to_time: option.Option(json_timestamp.Timestamp),
    export_view_type: option.Option(ExportViewType),
  )
}

pub fn incremental_export_specification_default() -> IncrementalExportSpecification {
  IncrementalExportSpecification(
    export_from_time: option.None,
    export_to_time: option.None,
    export_view_type: option.None,
  )
}

pub fn encode_incremental_export_specification_struct(
  input: IncrementalExportSpecification,
) -> json.Json {
  let pairs = []
  let pairs = case input.export_from_time {
    option.Some(v) -> [
      #("ExportFromTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.export_to_time {
    option.Some(v) -> [
      #("ExportToTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.export_view_type {
    option.Some(v) -> [
      #("ExportViewType", encode_export_view_type_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_incremental_export_specification_struct_top(
  input: IncrementalExportSpecification,
) -> json.Json {
  let pairs = []
  let pairs = case input.export_from_time {
    option.Some(v) -> [
      #("ExportFromTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.export_to_time {
    option.Some(v) -> [
      #("ExportToTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.export_view_type {
    option.Some(v) -> [
      #("ExportViewType", encode_export_view_type_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_incremental_export_specification_struct() -> decode.Decoder(
  IncrementalExportSpecification,
) {
  use <- decode.recursive
  use export_from_time <- decode.optional_field(
    "ExportFromTime",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use export_to_time <- decode.optional_field(
    "ExportToTime",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use export_view_type <- decode.optional_field(
    "ExportViewType",
    option.None,
    decode.optional(decode_export_view_type_enum()),
  )
  decode.success(IncrementalExportSpecification(
    export_from_time: export_from_time,
    export_to_time: export_to_time,
    export_view_type: export_view_type,
  ))
}

pub type ExportViewType {
  ExportViewTypeNewAndOldImages
  ExportViewTypeNewImage
}

pub fn encode_export_view_type_enum(v: ExportViewType) -> json.Json {
  case v {
    ExportViewTypeNewAndOldImages -> json.string("NEW_AND_OLD_IMAGES")
    ExportViewTypeNewImage -> json.string("NEW_IMAGE")
  }
}

pub fn decode_export_view_type_enum() -> decode.Decoder(ExportViewType) {
  decode.then(decode.string, fn(s) {
    case s {
      "NEW_AND_OLD_IMAGES" -> decode.success(ExportViewTypeNewAndOldImages)
      "NEW_IMAGE" -> decode.success(ExportViewTypeNewImage)
      _ -> decode.failure(ExportViewTypeNewAndOldImages, "unknown enum value")
    }
  })
}

pub type S3SseAlgorithm {
  S3SseAlgorithmAes256
  S3SseAlgorithmKms
}

pub fn encode_s3_sse_algorithm_enum(v: S3SseAlgorithm) -> json.Json {
  case v {
    S3SseAlgorithmAes256 -> json.string("AES256")
    S3SseAlgorithmKms -> json.string("KMS")
  }
}

pub fn decode_s3_sse_algorithm_enum() -> decode.Decoder(S3SseAlgorithm) {
  decode.then(decode.string, fn(s) {
    case s {
      "AES256" -> decode.success(S3SseAlgorithmAes256)
      "KMS" -> decode.success(S3SseAlgorithmKms)
      _ -> decode.failure(S3SseAlgorithmAes256, "unknown enum value")
    }
  })
}

pub type ExportNotFoundException {
  ExportNotFoundException(message: option.Option(String))
}

pub fn export_not_found_exception_default() -> ExportNotFoundException {
  ExportNotFoundException(message: option.None)
}

pub fn encode_export_not_found_exception_struct(
  input: ExportNotFoundException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_export_not_found_exception_struct_top(
  input: ExportNotFoundException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_export_not_found_exception_struct() -> decode.Decoder(
  ExportNotFoundException,
) {
  use <- decode.recursive
  use message <- decode.optional_field(
    "message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ExportNotFoundException(message: message))
}

pub type DescribeGlobalTableInput {
  DescribeGlobalTableInput(global_table_name: option.Option(String))
}

pub fn describe_global_table_input_default() -> DescribeGlobalTableInput {
  DescribeGlobalTableInput(global_table_name: option.None)
}

pub fn encode_describe_global_table_input_struct(
  input: DescribeGlobalTableInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.global_table_name {
    option.Some(v) -> [#("GlobalTableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_describe_global_table_input_struct_top(
  input: DescribeGlobalTableInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.global_table_name {
    option.Some(v) -> [#("GlobalTableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_describe_global_table_input_struct() -> decode.Decoder(
  DescribeGlobalTableInput,
) {
  use <- decode.recursive
  use global_table_name <- decode.optional_field(
    "GlobalTableName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DescribeGlobalTableInput(global_table_name: global_table_name))
}

pub type DescribeGlobalTableOutput {
  DescribeGlobalTableOutput(
    global_table_description: option.Option(GlobalTableDescription),
  )
}

pub fn describe_global_table_output_default() -> DescribeGlobalTableOutput {
  DescribeGlobalTableOutput(global_table_description: option.None)
}

pub fn encode_describe_global_table_output_struct(
  input: DescribeGlobalTableOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.global_table_description {
    option.Some(v) -> [
      #("GlobalTableDescription", encode_global_table_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_describe_global_table_output_struct_top(
  input: DescribeGlobalTableOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.global_table_description {
    option.Some(v) -> [
      #("GlobalTableDescription", encode_global_table_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_describe_global_table_output_struct() -> decode.Decoder(
  DescribeGlobalTableOutput,
) {
  use <- decode.recursive
  use global_table_description <- decode.optional_field(
    "GlobalTableDescription",
    option.None,
    decode.optional(decode_global_table_description_struct()),
  )
  decode.success(DescribeGlobalTableOutput(
    global_table_description: global_table_description,
  ))
}

pub type GlobalTableNotFoundException {
  GlobalTableNotFoundException(message: option.Option(String))
}

pub fn global_table_not_found_exception_default() -> GlobalTableNotFoundException {
  GlobalTableNotFoundException(message: option.None)
}

pub fn encode_global_table_not_found_exception_struct(
  input: GlobalTableNotFoundException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_global_table_not_found_exception_struct_top(
  input: GlobalTableNotFoundException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_global_table_not_found_exception_struct() -> decode.Decoder(
  GlobalTableNotFoundException,
) {
  use <- decode.recursive
  use message <- decode.optional_field(
    "message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GlobalTableNotFoundException(message: message))
}

pub type DescribeGlobalTableSettingsInput {
  DescribeGlobalTableSettingsInput(global_table_name: option.Option(String))
}

pub fn describe_global_table_settings_input_default() -> DescribeGlobalTableSettingsInput {
  DescribeGlobalTableSettingsInput(global_table_name: option.None)
}

pub fn encode_describe_global_table_settings_input_struct(
  input: DescribeGlobalTableSettingsInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.global_table_name {
    option.Some(v) -> [#("GlobalTableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_describe_global_table_settings_input_struct_top(
  input: DescribeGlobalTableSettingsInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.global_table_name {
    option.Some(v) -> [#("GlobalTableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_describe_global_table_settings_input_struct() -> decode.Decoder(
  DescribeGlobalTableSettingsInput,
) {
  use <- decode.recursive
  use global_table_name <- decode.optional_field(
    "GlobalTableName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DescribeGlobalTableSettingsInput(
    global_table_name: global_table_name,
  ))
}

pub type DescribeGlobalTableSettingsOutput {
  DescribeGlobalTableSettingsOutput(
    global_table_name: option.Option(String),
    replica_settings: option.Option(List(ReplicaSettingsDescription)),
  )
}

pub fn describe_global_table_settings_output_default() -> DescribeGlobalTableSettingsOutput {
  DescribeGlobalTableSettingsOutput(
    global_table_name: option.None,
    replica_settings: option.None,
  )
}

pub fn encode_describe_global_table_settings_output_struct(
  input: DescribeGlobalTableSettingsOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.global_table_name {
    option.Some(v) -> [#("GlobalTableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.replica_settings {
    option.Some(v) -> [
      #(
        "ReplicaSettings",
        fn(xs) { json.array(xs, encode_replica_settings_description_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_describe_global_table_settings_output_struct_top(
  input: DescribeGlobalTableSettingsOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.global_table_name {
    option.Some(v) -> [#("GlobalTableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.replica_settings {
    option.Some(v) -> [
      #(
        "ReplicaSettings",
        fn(xs) { json.array(xs, encode_replica_settings_description_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_describe_global_table_settings_output_struct() -> decode.Decoder(
  DescribeGlobalTableSettingsOutput,
) {
  use <- decode.recursive
  use global_table_name <- decode.optional_field(
    "GlobalTableName",
    option.None,
    decode.optional(decode.string),
  )
  use replica_settings <- decode.optional_field(
    "ReplicaSettings",
    option.None,
    decode.optional(decode.list(decode_replica_settings_description_struct())),
  )
  decode.success(DescribeGlobalTableSettingsOutput(
    global_table_name: global_table_name,
    replica_settings: replica_settings,
  ))
}

pub type ReplicaSettingsDescription {
  ReplicaSettingsDescription(
    region_name: option.Option(String),
    replica_billing_mode_summary: option.Option(BillingModeSummary),
    replica_global_secondary_index_settings: option.Option(
      List(ReplicaGlobalSecondaryIndexSettingsDescription),
    ),
    replica_provisioned_read_capacity_auto_scaling_settings: option.Option(
      AutoScalingSettingsDescription,
    ),
    replica_provisioned_read_capacity_units: option.Option(Int),
    replica_provisioned_write_capacity_auto_scaling_settings: option.Option(
      AutoScalingSettingsDescription,
    ),
    replica_provisioned_write_capacity_units: option.Option(Int),
    replica_status: option.Option(ReplicaStatus),
    replica_table_class_summary: option.Option(TableClassSummary),
  )
}

pub fn replica_settings_description_default() -> ReplicaSettingsDescription {
  ReplicaSettingsDescription(
    region_name: option.None,
    replica_billing_mode_summary: option.None,
    replica_global_secondary_index_settings: option.None,
    replica_provisioned_read_capacity_auto_scaling_settings: option.None,
    replica_provisioned_read_capacity_units: option.None,
    replica_provisioned_write_capacity_auto_scaling_settings: option.None,
    replica_provisioned_write_capacity_units: option.None,
    replica_status: option.None,
    replica_table_class_summary: option.None,
  )
}

pub fn encode_replica_settings_description_struct(
  input: ReplicaSettingsDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.region_name {
    option.Some(v) -> [#("RegionName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.replica_billing_mode_summary {
    option.Some(v) -> [
      #("ReplicaBillingModeSummary", encode_billing_mode_summary_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.replica_global_secondary_index_settings {
    option.Some(v) -> [
      #(
        "ReplicaGlobalSecondaryIndexSettings",
        fn(xs) {
          json.array(
            xs,
            encode_replica_global_secondary_index_settings_description_struct,
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case
    input.replica_provisioned_read_capacity_auto_scaling_settings
  {
    option.Some(v) -> [
      #(
        "ReplicaProvisionedReadCapacityAutoScalingSettings",
        encode_auto_scaling_settings_description_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.replica_provisioned_read_capacity_units {
    option.Some(v) -> [
      #("ReplicaProvisionedReadCapacityUnits", json.int(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case
    input.replica_provisioned_write_capacity_auto_scaling_settings
  {
    option.Some(v) -> [
      #(
        "ReplicaProvisionedWriteCapacityAutoScalingSettings",
        encode_auto_scaling_settings_description_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.replica_provisioned_write_capacity_units {
    option.Some(v) -> [
      #("ReplicaProvisionedWriteCapacityUnits", json.int(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.replica_status {
    option.Some(v) -> [
      #("ReplicaStatus", encode_replica_status_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.replica_table_class_summary {
    option.Some(v) -> [
      #("ReplicaTableClassSummary", encode_table_class_summary_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_replica_settings_description_struct_top(
  input: ReplicaSettingsDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.region_name {
    option.Some(v) -> [#("RegionName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.replica_billing_mode_summary {
    option.Some(v) -> [
      #("ReplicaBillingModeSummary", encode_billing_mode_summary_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.replica_global_secondary_index_settings {
    option.Some(v) -> [
      #(
        "ReplicaGlobalSecondaryIndexSettings",
        fn(xs) {
          json.array(
            xs,
            encode_replica_global_secondary_index_settings_description_struct,
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case
    input.replica_provisioned_read_capacity_auto_scaling_settings
  {
    option.Some(v) -> [
      #(
        "ReplicaProvisionedReadCapacityAutoScalingSettings",
        encode_auto_scaling_settings_description_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.replica_provisioned_read_capacity_units {
    option.Some(v) -> [
      #("ReplicaProvisionedReadCapacityUnits", json.int(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case
    input.replica_provisioned_write_capacity_auto_scaling_settings
  {
    option.Some(v) -> [
      #(
        "ReplicaProvisionedWriteCapacityAutoScalingSettings",
        encode_auto_scaling_settings_description_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.replica_provisioned_write_capacity_units {
    option.Some(v) -> [
      #("ReplicaProvisionedWriteCapacityUnits", json.int(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.replica_status {
    option.Some(v) -> [
      #("ReplicaStatus", encode_replica_status_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.replica_table_class_summary {
    option.Some(v) -> [
      #("ReplicaTableClassSummary", encode_table_class_summary_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_replica_settings_description_struct() -> decode.Decoder(
  ReplicaSettingsDescription,
) {
  use <- decode.recursive
  use region_name <- decode.optional_field(
    "RegionName",
    option.None,
    decode.optional(decode.string),
  )
  use replica_billing_mode_summary <- decode.optional_field(
    "ReplicaBillingModeSummary",
    option.None,
    decode.optional(decode_billing_mode_summary_struct()),
  )
  use replica_global_secondary_index_settings <- decode.optional_field(
    "ReplicaGlobalSecondaryIndexSettings",
    option.None,
    decode.optional(
      decode.list(
        decode_replica_global_secondary_index_settings_description_struct(),
      ),
    ),
  )
  use replica_provisioned_read_capacity_auto_scaling_settings <- decode.optional_field(
    "ReplicaProvisionedReadCapacityAutoScalingSettings",
    option.None,
    decode.optional(decode_auto_scaling_settings_description_struct()),
  )
  use replica_provisioned_read_capacity_units <- decode.optional_field(
    "ReplicaProvisionedReadCapacityUnits",
    option.None,
    decode.optional(decode.int),
  )
  use replica_provisioned_write_capacity_auto_scaling_settings <- decode.optional_field(
    "ReplicaProvisionedWriteCapacityAutoScalingSettings",
    option.None,
    decode.optional(decode_auto_scaling_settings_description_struct()),
  )
  use replica_provisioned_write_capacity_units <- decode.optional_field(
    "ReplicaProvisionedWriteCapacityUnits",
    option.None,
    decode.optional(decode.int),
  )
  use replica_status <- decode.optional_field(
    "ReplicaStatus",
    option.None,
    decode.optional(decode_replica_status_enum()),
  )
  use replica_table_class_summary <- decode.optional_field(
    "ReplicaTableClassSummary",
    option.None,
    decode.optional(decode_table_class_summary_struct()),
  )
  decode.success(ReplicaSettingsDescription(
    region_name: region_name,
    replica_billing_mode_summary: replica_billing_mode_summary,
    replica_global_secondary_index_settings: replica_global_secondary_index_settings,
    replica_provisioned_read_capacity_auto_scaling_settings: replica_provisioned_read_capacity_auto_scaling_settings,
    replica_provisioned_read_capacity_units: replica_provisioned_read_capacity_units,
    replica_provisioned_write_capacity_auto_scaling_settings: replica_provisioned_write_capacity_auto_scaling_settings,
    replica_provisioned_write_capacity_units: replica_provisioned_write_capacity_units,
    replica_status: replica_status,
    replica_table_class_summary: replica_table_class_summary,
  ))
}

pub type ReplicaGlobalSecondaryIndexSettingsDescription {
  ReplicaGlobalSecondaryIndexSettingsDescription(
    index_name: option.Option(String),
    index_status: option.Option(IndexStatus),
    provisioned_read_capacity_auto_scaling_settings: option.Option(
      AutoScalingSettingsDescription,
    ),
    provisioned_read_capacity_units: option.Option(Int),
    provisioned_write_capacity_auto_scaling_settings: option.Option(
      AutoScalingSettingsDescription,
    ),
    provisioned_write_capacity_units: option.Option(Int),
  )
}

pub fn replica_global_secondary_index_settings_description_default() -> ReplicaGlobalSecondaryIndexSettingsDescription {
  ReplicaGlobalSecondaryIndexSettingsDescription(
    index_name: option.None,
    index_status: option.None,
    provisioned_read_capacity_auto_scaling_settings: option.None,
    provisioned_read_capacity_units: option.None,
    provisioned_write_capacity_auto_scaling_settings: option.None,
    provisioned_write_capacity_units: option.None,
  )
}

pub fn encode_replica_global_secondary_index_settings_description_struct(
  input: ReplicaGlobalSecondaryIndexSettingsDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.index_status {
    option.Some(v) -> [#("IndexStatus", encode_index_status_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.provisioned_read_capacity_auto_scaling_settings {
    option.Some(v) -> [
      #(
        "ProvisionedReadCapacityAutoScalingSettings",
        encode_auto_scaling_settings_description_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_read_capacity_units {
    option.Some(v) -> [#("ProvisionedReadCapacityUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.provisioned_write_capacity_auto_scaling_settings {
    option.Some(v) -> [
      #(
        "ProvisionedWriteCapacityAutoScalingSettings",
        encode_auto_scaling_settings_description_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_write_capacity_units {
    option.Some(v) -> [#("ProvisionedWriteCapacityUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_replica_global_secondary_index_settings_description_struct_top(
  input: ReplicaGlobalSecondaryIndexSettingsDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.index_status {
    option.Some(v) -> [#("IndexStatus", encode_index_status_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.provisioned_read_capacity_auto_scaling_settings {
    option.Some(v) -> [
      #(
        "ProvisionedReadCapacityAutoScalingSettings",
        encode_auto_scaling_settings_description_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_read_capacity_units {
    option.Some(v) -> [#("ProvisionedReadCapacityUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.provisioned_write_capacity_auto_scaling_settings {
    option.Some(v) -> [
      #(
        "ProvisionedWriteCapacityAutoScalingSettings",
        encode_auto_scaling_settings_description_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_write_capacity_units {
    option.Some(v) -> [#("ProvisionedWriteCapacityUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_replica_global_secondary_index_settings_description_struct() -> decode.Decoder(
  ReplicaGlobalSecondaryIndexSettingsDescription,
) {
  use <- decode.recursive
  use index_name <- decode.optional_field(
    "IndexName",
    option.None,
    decode.optional(decode.string),
  )
  use index_status <- decode.optional_field(
    "IndexStatus",
    option.None,
    decode.optional(decode_index_status_enum()),
  )
  use provisioned_read_capacity_auto_scaling_settings <- decode.optional_field(
    "ProvisionedReadCapacityAutoScalingSettings",
    option.None,
    decode.optional(decode_auto_scaling_settings_description_struct()),
  )
  use provisioned_read_capacity_units <- decode.optional_field(
    "ProvisionedReadCapacityUnits",
    option.None,
    decode.optional(decode.int),
  )
  use provisioned_write_capacity_auto_scaling_settings <- decode.optional_field(
    "ProvisionedWriteCapacityAutoScalingSettings",
    option.None,
    decode.optional(decode_auto_scaling_settings_description_struct()),
  )
  use provisioned_write_capacity_units <- decode.optional_field(
    "ProvisionedWriteCapacityUnits",
    option.None,
    decode.optional(decode.int),
  )
  decode.success(ReplicaGlobalSecondaryIndexSettingsDescription(
    index_name: index_name,
    index_status: index_status,
    provisioned_read_capacity_auto_scaling_settings: provisioned_read_capacity_auto_scaling_settings,
    provisioned_read_capacity_units: provisioned_read_capacity_units,
    provisioned_write_capacity_auto_scaling_settings: provisioned_write_capacity_auto_scaling_settings,
    provisioned_write_capacity_units: provisioned_write_capacity_units,
  ))
}

pub type AutoScalingSettingsDescription {
  AutoScalingSettingsDescription(
    auto_scaling_disabled: option.Option(Bool),
    auto_scaling_role_arn: option.Option(String),
    maximum_units: option.Option(Int),
    minimum_units: option.Option(Int),
    scaling_policies: option.Option(List(AutoScalingPolicyDescription)),
  )
}

pub fn auto_scaling_settings_description_default() -> AutoScalingSettingsDescription {
  AutoScalingSettingsDescription(
    auto_scaling_disabled: option.None,
    auto_scaling_role_arn: option.None,
    maximum_units: option.None,
    minimum_units: option.None,
    scaling_policies: option.None,
  )
}

pub fn encode_auto_scaling_settings_description_struct(
  input: AutoScalingSettingsDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.auto_scaling_disabled {
    option.Some(v) -> [#("AutoScalingDisabled", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.auto_scaling_role_arn {
    option.Some(v) -> [#("AutoScalingRoleArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.maximum_units {
    option.Some(v) -> [#("MaximumUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.minimum_units {
    option.Some(v) -> [#("MinimumUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.scaling_policies {
    option.Some(v) -> [
      #(
        "ScalingPolicies",
        fn(xs) { json.array(xs, encode_auto_scaling_policy_description_struct) }(
          v,
        ),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_auto_scaling_settings_description_struct_top(
  input: AutoScalingSettingsDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.auto_scaling_disabled {
    option.Some(v) -> [#("AutoScalingDisabled", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.auto_scaling_role_arn {
    option.Some(v) -> [#("AutoScalingRoleArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.maximum_units {
    option.Some(v) -> [#("MaximumUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.minimum_units {
    option.Some(v) -> [#("MinimumUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.scaling_policies {
    option.Some(v) -> [
      #(
        "ScalingPolicies",
        fn(xs) { json.array(xs, encode_auto_scaling_policy_description_struct) }(
          v,
        ),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_auto_scaling_settings_description_struct() -> decode.Decoder(
  AutoScalingSettingsDescription,
) {
  use <- decode.recursive
  use auto_scaling_disabled <- decode.optional_field(
    "AutoScalingDisabled",
    option.None,
    decode.optional(decode.bool),
  )
  use auto_scaling_role_arn <- decode.optional_field(
    "AutoScalingRoleArn",
    option.None,
    decode.optional(decode.string),
  )
  use maximum_units <- decode.optional_field(
    "MaximumUnits",
    option.None,
    decode.optional(decode.int),
  )
  use minimum_units <- decode.optional_field(
    "MinimumUnits",
    option.None,
    decode.optional(decode.int),
  )
  use scaling_policies <- decode.optional_field(
    "ScalingPolicies",
    option.None,
    decode.optional(
      decode.list(decode_auto_scaling_policy_description_struct()),
    ),
  )
  decode.success(AutoScalingSettingsDescription(
    auto_scaling_disabled: auto_scaling_disabled,
    auto_scaling_role_arn: auto_scaling_role_arn,
    maximum_units: maximum_units,
    minimum_units: minimum_units,
    scaling_policies: scaling_policies,
  ))
}

pub type AutoScalingPolicyDescription {
  AutoScalingPolicyDescription(
    policy_name: option.Option(String),
    target_tracking_scaling_policy_configuration: option.Option(
      AutoScalingTargetTrackingScalingPolicyConfigurationDescription,
    ),
  )
}

pub fn auto_scaling_policy_description_default() -> AutoScalingPolicyDescription {
  AutoScalingPolicyDescription(
    policy_name: option.None,
    target_tracking_scaling_policy_configuration: option.None,
  )
}

pub fn encode_auto_scaling_policy_description_struct(
  input: AutoScalingPolicyDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.policy_name {
    option.Some(v) -> [#("PolicyName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.target_tracking_scaling_policy_configuration {
    option.Some(v) -> [
      #(
        "TargetTrackingScalingPolicyConfiguration",
        encode_auto_scaling_target_tracking_scaling_policy_configuration_description_struct(
          v,
        ),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_auto_scaling_policy_description_struct_top(
  input: AutoScalingPolicyDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.policy_name {
    option.Some(v) -> [#("PolicyName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.target_tracking_scaling_policy_configuration {
    option.Some(v) -> [
      #(
        "TargetTrackingScalingPolicyConfiguration",
        encode_auto_scaling_target_tracking_scaling_policy_configuration_description_struct(
          v,
        ),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_auto_scaling_policy_description_struct() -> decode.Decoder(
  AutoScalingPolicyDescription,
) {
  use <- decode.recursive
  use policy_name <- decode.optional_field(
    "PolicyName",
    option.None,
    decode.optional(decode.string),
  )
  use target_tracking_scaling_policy_configuration <- decode.optional_field(
    "TargetTrackingScalingPolicyConfiguration",
    option.None,
    decode.optional(
      decode_auto_scaling_target_tracking_scaling_policy_configuration_description_struct(),
    ),
  )
  decode.success(AutoScalingPolicyDescription(
    policy_name: policy_name,
    target_tracking_scaling_policy_configuration: target_tracking_scaling_policy_configuration,
  ))
}

pub type AutoScalingTargetTrackingScalingPolicyConfigurationDescription {
  AutoScalingTargetTrackingScalingPolicyConfigurationDescription(
    disable_scale_in: option.Option(Bool),
    scale_in_cooldown: option.Option(Int),
    scale_out_cooldown: option.Option(Int),
    target_value: option.Option(json_float.SmithyFloat),
  )
}

pub fn auto_scaling_target_tracking_scaling_policy_configuration_description_default() -> AutoScalingTargetTrackingScalingPolicyConfigurationDescription {
  AutoScalingTargetTrackingScalingPolicyConfigurationDescription(
    disable_scale_in: option.None,
    scale_in_cooldown: option.None,
    scale_out_cooldown: option.None,
    target_value: option.None,
  )
}

pub fn encode_auto_scaling_target_tracking_scaling_policy_configuration_description_struct(
  input: AutoScalingTargetTrackingScalingPolicyConfigurationDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.disable_scale_in {
    option.Some(v) -> [#("DisableScaleIn", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.scale_in_cooldown {
    option.Some(v) -> [#("ScaleInCooldown", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.scale_out_cooldown {
    option.Some(v) -> [#("ScaleOutCooldown", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.target_value {
    option.Some(v) -> [#("TargetValue", json_float.encode(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_auto_scaling_target_tracking_scaling_policy_configuration_description_struct_top(
  input: AutoScalingTargetTrackingScalingPolicyConfigurationDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.disable_scale_in {
    option.Some(v) -> [#("DisableScaleIn", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.scale_in_cooldown {
    option.Some(v) -> [#("ScaleInCooldown", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.scale_out_cooldown {
    option.Some(v) -> [#("ScaleOutCooldown", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.target_value {
    option.Some(v) -> [#("TargetValue", json_float.encode(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_auto_scaling_target_tracking_scaling_policy_configuration_description_struct() -> decode.Decoder(
  AutoScalingTargetTrackingScalingPolicyConfigurationDescription,
) {
  use <- decode.recursive
  use disable_scale_in <- decode.optional_field(
    "DisableScaleIn",
    option.None,
    decode.optional(decode.bool),
  )
  use scale_in_cooldown <- decode.optional_field(
    "ScaleInCooldown",
    option.None,
    decode.optional(decode.int),
  )
  use scale_out_cooldown <- decode.optional_field(
    "ScaleOutCooldown",
    option.None,
    decode.optional(decode.int),
  )
  use target_value <- decode.optional_field(
    "TargetValue",
    option.None,
    decode.optional(json_float.decoder()),
  )
  decode.success(AutoScalingTargetTrackingScalingPolicyConfigurationDescription(
    disable_scale_in: disable_scale_in,
    scale_in_cooldown: scale_in_cooldown,
    scale_out_cooldown: scale_out_cooldown,
    target_value: target_value,
  ))
}

pub type DescribeImportInput {
  DescribeImportInput(import_arn: option.Option(String))
}

pub fn describe_import_input_default() -> DescribeImportInput {
  DescribeImportInput(import_arn: option.None)
}

pub fn encode_describe_import_input_struct(
  input: DescribeImportInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.import_arn {
    option.Some(v) -> [#("ImportArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_describe_import_input_struct_top(
  input: DescribeImportInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.import_arn {
    option.Some(v) -> [#("ImportArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_describe_import_input_struct() -> decode.Decoder(
  DescribeImportInput,
) {
  use <- decode.recursive
  use import_arn <- decode.optional_field(
    "ImportArn",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DescribeImportInput(import_arn: import_arn))
}

pub type DescribeImportOutput {
  DescribeImportOutput(
    import_table_description: option.Option(ImportTableDescription),
  )
}

pub fn describe_import_output_default() -> DescribeImportOutput {
  DescribeImportOutput(import_table_description: option.None)
}

pub fn encode_describe_import_output_struct(
  input: DescribeImportOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.import_table_description {
    option.Some(v) -> [
      #("ImportTableDescription", encode_import_table_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_describe_import_output_struct_top(
  input: DescribeImportOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.import_table_description {
    option.Some(v) -> [
      #("ImportTableDescription", encode_import_table_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_describe_import_output_struct() -> decode.Decoder(
  DescribeImportOutput,
) {
  use <- decode.recursive
  use import_table_description <- decode.optional_field(
    "ImportTableDescription",
    option.None,
    decode.optional(decode_import_table_description_struct()),
  )
  decode.success(DescribeImportOutput(
    import_table_description: import_table_description,
  ))
}

pub type ImportTableDescription {
  ImportTableDescription(
    client_token: option.Option(String),
    cloud_watch_log_group_arn: option.Option(String),
    end_time: option.Option(json_timestamp.Timestamp),
    error_count: option.Option(Int),
    failure_code: option.Option(String),
    failure_message: option.Option(String),
    import_arn: option.Option(String),
    import_status: option.Option(ImportStatus),
    imported_item_count: option.Option(Int),
    input_compression_type: option.Option(InputCompressionType),
    input_format: option.Option(InputFormat),
    input_format_options: option.Option(InputFormatOptions),
    processed_item_count: option.Option(Int),
    processed_size_bytes: option.Option(Int),
    s3_bucket_source: option.Option(S3BucketSource),
    start_time: option.Option(json_timestamp.Timestamp),
    table_arn: option.Option(String),
    table_creation_parameters: option.Option(TableCreationParameters),
    table_id: option.Option(String),
  )
}

pub fn import_table_description_default() -> ImportTableDescription {
  ImportTableDescription(
    client_token: option.None,
    cloud_watch_log_group_arn: option.None,
    end_time: option.None,
    error_count: option.None,
    failure_code: option.None,
    failure_message: option.None,
    import_arn: option.None,
    import_status: option.None,
    imported_item_count: option.None,
    input_compression_type: option.None,
    input_format: option.None,
    input_format_options: option.None,
    processed_item_count: option.None,
    processed_size_bytes: option.None,
    s3_bucket_source: option.None,
    start_time: option.None,
    table_arn: option.None,
    table_creation_parameters: option.None,
    table_id: option.None,
  )
}

pub fn encode_import_table_description_struct(
  input: ImportTableDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.client_token {
    option.Some(v) -> [#("ClientToken", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.cloud_watch_log_group_arn {
    option.Some(v) -> [#("CloudWatchLogGroupArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.end_time {
    option.Some(v) -> [
      #("EndTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.error_count {
    option.Some(v) -> [#("ErrorCount", json.int(v)), ..pairs]
    option.None -> [#("ErrorCount", json.int(0)), ..pairs]
  }
  let pairs = case input.failure_code {
    option.Some(v) -> [#("FailureCode", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.failure_message {
    option.Some(v) -> [#("FailureMessage", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.import_arn {
    option.Some(v) -> [#("ImportArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.import_status {
    option.Some(v) -> [#("ImportStatus", encode_import_status_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.imported_item_count {
    option.Some(v) -> [#("ImportedItemCount", json.int(v)), ..pairs]
    option.None -> [#("ImportedItemCount", json.int(0)), ..pairs]
  }
  let pairs = case input.input_compression_type {
    option.Some(v) -> [
      #("InputCompressionType", encode_input_compression_type_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.input_format {
    option.Some(v) -> [#("InputFormat", encode_input_format_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.input_format_options {
    option.Some(v) -> [
      #("InputFormatOptions", encode_input_format_options_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.processed_item_count {
    option.Some(v) -> [#("ProcessedItemCount", json.int(v)), ..pairs]
    option.None -> [#("ProcessedItemCount", json.int(0)), ..pairs]
  }
  let pairs = case input.processed_size_bytes {
    option.Some(v) -> [#("ProcessedSizeBytes", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.s3_bucket_source {
    option.Some(v) -> [
      #("S3BucketSource", encode_s3_bucket_source_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.start_time {
    option.Some(v) -> [
      #("StartTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_arn {
    option.Some(v) -> [#("TableArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_creation_parameters {
    option.Some(v) -> [
      #("TableCreationParameters", encode_table_creation_parameters_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_id {
    option.Some(v) -> [#("TableId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_import_table_description_struct_top(
  input: ImportTableDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.client_token {
    option.Some(v) -> [#("ClientToken", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.cloud_watch_log_group_arn {
    option.Some(v) -> [#("CloudWatchLogGroupArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.end_time {
    option.Some(v) -> [
      #("EndTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.error_count {
    option.Some(v) -> [#("ErrorCount", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.failure_code {
    option.Some(v) -> [#("FailureCode", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.failure_message {
    option.Some(v) -> [#("FailureMessage", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.import_arn {
    option.Some(v) -> [#("ImportArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.import_status {
    option.Some(v) -> [#("ImportStatus", encode_import_status_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.imported_item_count {
    option.Some(v) -> [#("ImportedItemCount", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.input_compression_type {
    option.Some(v) -> [
      #("InputCompressionType", encode_input_compression_type_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.input_format {
    option.Some(v) -> [#("InputFormat", encode_input_format_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.input_format_options {
    option.Some(v) -> [
      #("InputFormatOptions", encode_input_format_options_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.processed_item_count {
    option.Some(v) -> [#("ProcessedItemCount", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.processed_size_bytes {
    option.Some(v) -> [#("ProcessedSizeBytes", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.s3_bucket_source {
    option.Some(v) -> [
      #("S3BucketSource", encode_s3_bucket_source_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.start_time {
    option.Some(v) -> [
      #("StartTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_arn {
    option.Some(v) -> [#("TableArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_creation_parameters {
    option.Some(v) -> [
      #("TableCreationParameters", encode_table_creation_parameters_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_id {
    option.Some(v) -> [#("TableId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_import_table_description_struct() -> decode.Decoder(
  ImportTableDescription,
) {
  use <- decode.recursive
  use client_token <- decode.optional_field(
    "ClientToken",
    option.None,
    decode.optional(decode.string),
  )
  use cloud_watch_log_group_arn <- decode.optional_field(
    "CloudWatchLogGroupArn",
    option.None,
    decode.optional(decode.string),
  )
  use end_time <- decode.optional_field(
    "EndTime",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use error_count <- decode.optional_field(
    "ErrorCount",
    option.None,
    decode.optional(decode.int),
  )
  use failure_code <- decode.optional_field(
    "FailureCode",
    option.None,
    decode.optional(decode.string),
  )
  use failure_message <- decode.optional_field(
    "FailureMessage",
    option.None,
    decode.optional(decode.string),
  )
  use import_arn <- decode.optional_field(
    "ImportArn",
    option.None,
    decode.optional(decode.string),
  )
  use import_status <- decode.optional_field(
    "ImportStatus",
    option.None,
    decode.optional(decode_import_status_enum()),
  )
  use imported_item_count <- decode.optional_field(
    "ImportedItemCount",
    option.None,
    decode.optional(decode.int),
  )
  use input_compression_type <- decode.optional_field(
    "InputCompressionType",
    option.None,
    decode.optional(decode_input_compression_type_enum()),
  )
  use input_format <- decode.optional_field(
    "InputFormat",
    option.None,
    decode.optional(decode_input_format_enum()),
  )
  use input_format_options <- decode.optional_field(
    "InputFormatOptions",
    option.None,
    decode.optional(decode_input_format_options_struct()),
  )
  use processed_item_count <- decode.optional_field(
    "ProcessedItemCount",
    option.None,
    decode.optional(decode.int),
  )
  use processed_size_bytes <- decode.optional_field(
    "ProcessedSizeBytes",
    option.None,
    decode.optional(decode.int),
  )
  use s3_bucket_source <- decode.optional_field(
    "S3BucketSource",
    option.None,
    decode.optional(decode_s3_bucket_source_struct()),
  )
  use start_time <- decode.optional_field(
    "StartTime",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use table_arn <- decode.optional_field(
    "TableArn",
    option.None,
    decode.optional(decode.string),
  )
  use table_creation_parameters <- decode.optional_field(
    "TableCreationParameters",
    option.None,
    decode.optional(decode_table_creation_parameters_struct()),
  )
  use table_id <- decode.optional_field(
    "TableId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ImportTableDescription(
    client_token: client_token,
    cloud_watch_log_group_arn: cloud_watch_log_group_arn,
    end_time: end_time,
    error_count: error_count,
    failure_code: failure_code,
    failure_message: failure_message,
    import_arn: import_arn,
    import_status: import_status,
    imported_item_count: imported_item_count,
    input_compression_type: input_compression_type,
    input_format: input_format,
    input_format_options: input_format_options,
    processed_item_count: processed_item_count,
    processed_size_bytes: processed_size_bytes,
    s3_bucket_source: s3_bucket_source,
    start_time: start_time,
    table_arn: table_arn,
    table_creation_parameters: table_creation_parameters,
    table_id: table_id,
  ))
}

pub type ImportStatus {
  ImportStatusCancelled
  ImportStatusCancelling
  ImportStatusCompleted
  ImportStatusFailed
  ImportStatusInProgress
}

pub fn encode_import_status_enum(v: ImportStatus) -> json.Json {
  case v {
    ImportStatusCancelled -> json.string("CANCELLED")
    ImportStatusCancelling -> json.string("CANCELLING")
    ImportStatusCompleted -> json.string("COMPLETED")
    ImportStatusFailed -> json.string("FAILED")
    ImportStatusInProgress -> json.string("IN_PROGRESS")
  }
}

pub fn decode_import_status_enum() -> decode.Decoder(ImportStatus) {
  decode.then(decode.string, fn(s) {
    case s {
      "CANCELLED" -> decode.success(ImportStatusCancelled)
      "CANCELLING" -> decode.success(ImportStatusCancelling)
      "COMPLETED" -> decode.success(ImportStatusCompleted)
      "FAILED" -> decode.success(ImportStatusFailed)
      "IN_PROGRESS" -> decode.success(ImportStatusInProgress)
      _ -> decode.failure(ImportStatusCancelled, "unknown enum value")
    }
  })
}

pub type InputCompressionType {
  InputCompressionTypeGzip
  InputCompressionTypeNone
  InputCompressionTypeZstd
}

pub fn encode_input_compression_type_enum(
  v: InputCompressionType,
) -> json.Json {
  case v {
    InputCompressionTypeGzip -> json.string("GZIP")
    InputCompressionTypeNone -> json.string("NONE")
    InputCompressionTypeZstd -> json.string("ZSTD")
  }
}

pub fn decode_input_compression_type_enum() -> decode.Decoder(
  InputCompressionType,
) {
  decode.then(decode.string, fn(s) {
    case s {
      "GZIP" -> decode.success(InputCompressionTypeGzip)
      "NONE" -> decode.success(InputCompressionTypeNone)
      "ZSTD" -> decode.success(InputCompressionTypeZstd)
      _ -> decode.failure(InputCompressionTypeGzip, "unknown enum value")
    }
  })
}

pub type InputFormat {
  InputFormatCsv
  InputFormatDynamodbJson
  InputFormatIon
}

pub fn encode_input_format_enum(v: InputFormat) -> json.Json {
  case v {
    InputFormatCsv -> json.string("CSV")
    InputFormatDynamodbJson -> json.string("DYNAMODB_JSON")
    InputFormatIon -> json.string("ION")
  }
}

pub fn decode_input_format_enum() -> decode.Decoder(InputFormat) {
  decode.then(decode.string, fn(s) {
    case s {
      "CSV" -> decode.success(InputFormatCsv)
      "DYNAMODB_JSON" -> decode.success(InputFormatDynamodbJson)
      "ION" -> decode.success(InputFormatIon)
      _ -> decode.failure(InputFormatCsv, "unknown enum value")
    }
  })
}

pub type InputFormatOptions {
  InputFormatOptions(csv: option.Option(CsvOptions))
}

pub fn input_format_options_default() -> InputFormatOptions {
  InputFormatOptions(csv: option.None)
}

pub fn encode_input_format_options_struct(
  input: InputFormatOptions,
) -> json.Json {
  let pairs = []
  let pairs = case input.csv {
    option.Some(v) -> [#("Csv", encode_csv_options_struct(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_input_format_options_struct_top(
  input: InputFormatOptions,
) -> json.Json {
  let pairs = []
  let pairs = case input.csv {
    option.Some(v) -> [#("Csv", encode_csv_options_struct(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_input_format_options_struct() -> decode.Decoder(
  InputFormatOptions,
) {
  use <- decode.recursive
  use csv <- decode.optional_field(
    "Csv",
    option.None,
    decode.optional(decode_csv_options_struct()),
  )
  decode.success(InputFormatOptions(csv: csv))
}

pub type CsvOptions {
  CsvOptions(
    delimiter: option.Option(String),
    header_list: option.Option(List(String)),
  )
}

pub fn csv_options_default() -> CsvOptions {
  CsvOptions(delimiter: option.None, header_list: option.None)
}

pub fn encode_csv_options_struct(input: CsvOptions) -> json.Json {
  let pairs = []
  let pairs = case input.delimiter {
    option.Some(v) -> [#("Delimiter", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.header_list {
    option.Some(v) -> [
      #("HeaderList", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_csv_options_struct_top(input: CsvOptions) -> json.Json {
  let pairs = []
  let pairs = case input.delimiter {
    option.Some(v) -> [#("Delimiter", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.header_list {
    option.Some(v) -> [
      #("HeaderList", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_csv_options_struct() -> decode.Decoder(CsvOptions) {
  use <- decode.recursive
  use delimiter <- decode.optional_field(
    "Delimiter",
    option.None,
    decode.optional(decode.string),
  )
  use header_list <- decode.optional_field(
    "HeaderList",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  decode.success(CsvOptions(delimiter: delimiter, header_list: header_list))
}

pub type S3BucketSource {
  S3BucketSource(
    s3_bucket: option.Option(String),
    s3_bucket_owner: option.Option(String),
    s3_key_prefix: option.Option(String),
  )
}

pub fn s3_bucket_source_default() -> S3BucketSource {
  S3BucketSource(
    s3_bucket: option.None,
    s3_bucket_owner: option.None,
    s3_key_prefix: option.None,
  )
}

pub fn encode_s3_bucket_source_struct(input: S3BucketSource) -> json.Json {
  let pairs = []
  let pairs = case input.s3_bucket {
    option.Some(v) -> [#("S3Bucket", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.s3_bucket_owner {
    option.Some(v) -> [#("S3BucketOwner", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.s3_key_prefix {
    option.Some(v) -> [#("S3KeyPrefix", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_s3_bucket_source_struct_top(input: S3BucketSource) -> json.Json {
  let pairs = []
  let pairs = case input.s3_bucket {
    option.Some(v) -> [#("S3Bucket", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.s3_bucket_owner {
    option.Some(v) -> [#("S3BucketOwner", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.s3_key_prefix {
    option.Some(v) -> [#("S3KeyPrefix", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_s3_bucket_source_struct() -> decode.Decoder(S3BucketSource) {
  use <- decode.recursive
  use s3_bucket <- decode.optional_field(
    "S3Bucket",
    option.None,
    decode.optional(decode.string),
  )
  use s3_bucket_owner <- decode.optional_field(
    "S3BucketOwner",
    option.None,
    decode.optional(decode.string),
  )
  use s3_key_prefix <- decode.optional_field(
    "S3KeyPrefix",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(S3BucketSource(
    s3_bucket: s3_bucket,
    s3_bucket_owner: s3_bucket_owner,
    s3_key_prefix: s3_key_prefix,
  ))
}

pub type TableCreationParameters {
  TableCreationParameters(
    attribute_definitions: option.Option(List(AttributeDefinition)),
    billing_mode: option.Option(BillingMode),
    global_secondary_indexes: option.Option(List(GlobalSecondaryIndex)),
    key_schema: option.Option(List(KeySchemaElement)),
    on_demand_throughput: option.Option(OnDemandThroughput),
    provisioned_throughput: option.Option(ProvisionedThroughput),
    sse_specification: option.Option(SSESpecification),
    table_name: option.Option(String),
  )
}

pub fn table_creation_parameters_default() -> TableCreationParameters {
  TableCreationParameters(
    attribute_definitions: option.None,
    billing_mode: option.None,
    global_secondary_indexes: option.None,
    key_schema: option.None,
    on_demand_throughput: option.None,
    provisioned_throughput: option.None,
    sse_specification: option.None,
    table_name: option.None,
  )
}

pub fn encode_table_creation_parameters_struct(
  input: TableCreationParameters,
) -> json.Json {
  let pairs = []
  let pairs = case input.attribute_definitions {
    option.Some(v) -> [
      #(
        "AttributeDefinitions",
        fn(xs) { json.array(xs, encode_attribute_definition_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.billing_mode {
    option.Some(v) -> [#("BillingMode", encode_billing_mode_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.global_secondary_indexes {
    option.Some(v) -> [
      #(
        "GlobalSecondaryIndexes",
        fn(xs) { json.array(xs, encode_global_secondary_index_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.key_schema {
    option.Some(v) -> [
      #(
        "KeySchema",
        fn(xs) { json.array(xs, encode_key_schema_element_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.on_demand_throughput {
    option.Some(v) -> [
      #("OnDemandThroughput", encode_on_demand_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_throughput {
    option.Some(v) -> [
      #("ProvisionedThroughput", encode_provisioned_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.sse_specification {
    option.Some(v) -> [
      #("SSESpecification", encode_sse_specification_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_table_creation_parameters_struct_top(
  input: TableCreationParameters,
) -> json.Json {
  let pairs = []
  let pairs = case input.attribute_definitions {
    option.Some(v) -> [
      #(
        "AttributeDefinitions",
        fn(xs) { json.array(xs, encode_attribute_definition_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.billing_mode {
    option.Some(v) -> [#("BillingMode", encode_billing_mode_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.global_secondary_indexes {
    option.Some(v) -> [
      #(
        "GlobalSecondaryIndexes",
        fn(xs) { json.array(xs, encode_global_secondary_index_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.key_schema {
    option.Some(v) -> [
      #(
        "KeySchema",
        fn(xs) { json.array(xs, encode_key_schema_element_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.on_demand_throughput {
    option.Some(v) -> [
      #("OnDemandThroughput", encode_on_demand_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_throughput {
    option.Some(v) -> [
      #("ProvisionedThroughput", encode_provisioned_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.sse_specification {
    option.Some(v) -> [
      #("SSESpecification", encode_sse_specification_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_table_creation_parameters_struct() -> decode.Decoder(
  TableCreationParameters,
) {
  use <- decode.recursive
  use attribute_definitions <- decode.optional_field(
    "AttributeDefinitions",
    option.None,
    decode.optional(decode.list(decode_attribute_definition_struct())),
  )
  use billing_mode <- decode.optional_field(
    "BillingMode",
    option.None,
    decode.optional(decode_billing_mode_enum()),
  )
  use global_secondary_indexes <- decode.optional_field(
    "GlobalSecondaryIndexes",
    option.None,
    decode.optional(decode.list(decode_global_secondary_index_struct())),
  )
  use key_schema <- decode.optional_field(
    "KeySchema",
    option.None,
    decode.optional(decode.list(decode_key_schema_element_struct())),
  )
  use on_demand_throughput <- decode.optional_field(
    "OnDemandThroughput",
    option.None,
    decode.optional(decode_on_demand_throughput_struct()),
  )
  use provisioned_throughput <- decode.optional_field(
    "ProvisionedThroughput",
    option.None,
    decode.optional(decode_provisioned_throughput_struct()),
  )
  use sse_specification <- decode.optional_field(
    "SSESpecification",
    option.None,
    decode.optional(decode_sse_specification_struct()),
  )
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(TableCreationParameters(
    attribute_definitions: attribute_definitions,
    billing_mode: billing_mode,
    global_secondary_indexes: global_secondary_indexes,
    key_schema: key_schema,
    on_demand_throughput: on_demand_throughput,
    provisioned_throughput: provisioned_throughput,
    sse_specification: sse_specification,
    table_name: table_name,
  ))
}

pub type ImportNotFoundException {
  ImportNotFoundException(message: option.Option(String))
}

pub fn import_not_found_exception_default() -> ImportNotFoundException {
  ImportNotFoundException(message: option.None)
}

pub fn encode_import_not_found_exception_struct(
  input: ImportNotFoundException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_import_not_found_exception_struct_top(
  input: ImportNotFoundException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_import_not_found_exception_struct() -> decode.Decoder(
  ImportNotFoundException,
) {
  use <- decode.recursive
  use message <- decode.optional_field(
    "message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ImportNotFoundException(message: message))
}

pub type DescribeKinesisStreamingDestinationInput {
  DescribeKinesisStreamingDestinationInput(table_name: option.Option(String))
}

pub fn describe_kinesis_streaming_destination_input_default() -> DescribeKinesisStreamingDestinationInput {
  DescribeKinesisStreamingDestinationInput(table_name: option.None)
}

pub fn encode_describe_kinesis_streaming_destination_input_struct(
  input: DescribeKinesisStreamingDestinationInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_describe_kinesis_streaming_destination_input_struct_top(
  input: DescribeKinesisStreamingDestinationInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_describe_kinesis_streaming_destination_input_struct() -> decode.Decoder(
  DescribeKinesisStreamingDestinationInput,
) {
  use <- decode.recursive
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DescribeKinesisStreamingDestinationInput(
    table_name: table_name,
  ))
}

pub type DescribeKinesisStreamingDestinationOutput {
  DescribeKinesisStreamingDestinationOutput(
    kinesis_data_stream_destinations: option.Option(
      List(KinesisDataStreamDestination),
    ),
    table_name: option.Option(String),
  )
}

pub fn describe_kinesis_streaming_destination_output_default() -> DescribeKinesisStreamingDestinationOutput {
  DescribeKinesisStreamingDestinationOutput(
    kinesis_data_stream_destinations: option.None,
    table_name: option.None,
  )
}

pub fn encode_describe_kinesis_streaming_destination_output_struct(
  input: DescribeKinesisStreamingDestinationOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.kinesis_data_stream_destinations {
    option.Some(v) -> [
      #(
        "KinesisDataStreamDestinations",
        fn(xs) { json.array(xs, encode_kinesis_data_stream_destination_struct) }(
          v,
        ),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_describe_kinesis_streaming_destination_output_struct_top(
  input: DescribeKinesisStreamingDestinationOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.kinesis_data_stream_destinations {
    option.Some(v) -> [
      #(
        "KinesisDataStreamDestinations",
        fn(xs) { json.array(xs, encode_kinesis_data_stream_destination_struct) }(
          v,
        ),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_describe_kinesis_streaming_destination_output_struct() -> decode.Decoder(
  DescribeKinesisStreamingDestinationOutput,
) {
  use <- decode.recursive
  use kinesis_data_stream_destinations <- decode.optional_field(
    "KinesisDataStreamDestinations",
    option.None,
    decode.optional(
      decode.list(decode_kinesis_data_stream_destination_struct()),
    ),
  )
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DescribeKinesisStreamingDestinationOutput(
    kinesis_data_stream_destinations: kinesis_data_stream_destinations,
    table_name: table_name,
  ))
}

pub type KinesisDataStreamDestination {
  KinesisDataStreamDestination(
    approximate_creation_date_time_precision: option.Option(
      ApproximateCreationDateTimePrecision,
    ),
    destination_status: option.Option(DestinationStatus),
    destination_status_description: option.Option(String),
    stream_arn: option.Option(String),
  )
}

pub fn kinesis_data_stream_destination_default() -> KinesisDataStreamDestination {
  KinesisDataStreamDestination(
    approximate_creation_date_time_precision: option.None,
    destination_status: option.None,
    destination_status_description: option.None,
    stream_arn: option.None,
  )
}

pub fn encode_kinesis_data_stream_destination_struct(
  input: KinesisDataStreamDestination,
) -> json.Json {
  let pairs = []
  let pairs = case input.approximate_creation_date_time_precision {
    option.Some(v) -> [
      #(
        "ApproximateCreationDateTimePrecision",
        encode_approximate_creation_date_time_precision_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.destination_status {
    option.Some(v) -> [
      #("DestinationStatus", encode_destination_status_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.destination_status_description {
    option.Some(v) -> [
      #("DestinationStatusDescription", json.string(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.stream_arn {
    option.Some(v) -> [#("StreamArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_kinesis_data_stream_destination_struct_top(
  input: KinesisDataStreamDestination,
) -> json.Json {
  let pairs = []
  let pairs = case input.approximate_creation_date_time_precision {
    option.Some(v) -> [
      #(
        "ApproximateCreationDateTimePrecision",
        encode_approximate_creation_date_time_precision_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.destination_status {
    option.Some(v) -> [
      #("DestinationStatus", encode_destination_status_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.destination_status_description {
    option.Some(v) -> [
      #("DestinationStatusDescription", json.string(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.stream_arn {
    option.Some(v) -> [#("StreamArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_kinesis_data_stream_destination_struct() -> decode.Decoder(
  KinesisDataStreamDestination,
) {
  use <- decode.recursive
  use approximate_creation_date_time_precision <- decode.optional_field(
    "ApproximateCreationDateTimePrecision",
    option.None,
    decode.optional(decode_approximate_creation_date_time_precision_enum()),
  )
  use destination_status <- decode.optional_field(
    "DestinationStatus",
    option.None,
    decode.optional(decode_destination_status_enum()),
  )
  use destination_status_description <- decode.optional_field(
    "DestinationStatusDescription",
    option.None,
    decode.optional(decode.string),
  )
  use stream_arn <- decode.optional_field(
    "StreamArn",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(KinesisDataStreamDestination(
    approximate_creation_date_time_precision: approximate_creation_date_time_precision,
    destination_status: destination_status,
    destination_status_description: destination_status_description,
    stream_arn: stream_arn,
  ))
}

pub type ApproximateCreationDateTimePrecision {
  ApproximateCreationDateTimePrecisionMicrosecond
  ApproximateCreationDateTimePrecisionMillisecond
}

pub fn encode_approximate_creation_date_time_precision_enum(
  v: ApproximateCreationDateTimePrecision,
) -> json.Json {
  case v {
    ApproximateCreationDateTimePrecisionMicrosecond ->
      json.string("MICROSECOND")
    ApproximateCreationDateTimePrecisionMillisecond ->
      json.string("MILLISECOND")
  }
}

pub fn decode_approximate_creation_date_time_precision_enum() -> decode.Decoder(
  ApproximateCreationDateTimePrecision,
) {
  decode.then(decode.string, fn(s) {
    case s {
      "MICROSECOND" ->
        decode.success(ApproximateCreationDateTimePrecisionMicrosecond)
      "MILLISECOND" ->
        decode.success(ApproximateCreationDateTimePrecisionMillisecond)
      _ ->
        decode.failure(
          ApproximateCreationDateTimePrecisionMicrosecond,
          "unknown enum value",
        )
    }
  })
}

pub type DestinationStatus {
  DestinationStatusActive
  DestinationStatusDisabled
  DestinationStatusDisabling
  DestinationStatusEnableFailed
  DestinationStatusEnabling
  DestinationStatusUpdating
}

pub fn encode_destination_status_enum(v: DestinationStatus) -> json.Json {
  case v {
    DestinationStatusActive -> json.string("ACTIVE")
    DestinationStatusDisabled -> json.string("DISABLED")
    DestinationStatusDisabling -> json.string("DISABLING")
    DestinationStatusEnableFailed -> json.string("ENABLE_FAILED")
    DestinationStatusEnabling -> json.string("ENABLING")
    DestinationStatusUpdating -> json.string("UPDATING")
  }
}

pub fn decode_destination_status_enum() -> decode.Decoder(DestinationStatus) {
  decode.then(decode.string, fn(s) {
    case s {
      "ACTIVE" -> decode.success(DestinationStatusActive)
      "DISABLED" -> decode.success(DestinationStatusDisabled)
      "DISABLING" -> decode.success(DestinationStatusDisabling)
      "ENABLE_FAILED" -> decode.success(DestinationStatusEnableFailed)
      "ENABLING" -> decode.success(DestinationStatusEnabling)
      "UPDATING" -> decode.success(DestinationStatusUpdating)
      _ -> decode.failure(DestinationStatusActive, "unknown enum value")
    }
  })
}

pub type DescribeLimitsInput {
  DescribeLimitsInput
}

pub fn describe_limits_input_default() -> DescribeLimitsInput {
  DescribeLimitsInput
}

pub fn encode_describe_limits_input_struct(
  _v: DescribeLimitsInput,
) -> json.Json {
  json.object([])
}

pub fn encode_describe_limits_input_struct_top(
  _v: DescribeLimitsInput,
) -> json.Json {
  json.object([])
}

pub fn decode_describe_limits_input_struct() -> decode.Decoder(
  DescribeLimitsInput,
) {
  decode.success(DescribeLimitsInput)
}

pub type DescribeLimitsOutput {
  DescribeLimitsOutput(
    account_max_read_capacity_units: option.Option(Int),
    account_max_write_capacity_units: option.Option(Int),
    table_max_read_capacity_units: option.Option(Int),
    table_max_write_capacity_units: option.Option(Int),
  )
}

pub fn describe_limits_output_default() -> DescribeLimitsOutput {
  DescribeLimitsOutput(
    account_max_read_capacity_units: option.None,
    account_max_write_capacity_units: option.None,
    table_max_read_capacity_units: option.None,
    table_max_write_capacity_units: option.None,
  )
}

pub fn encode_describe_limits_output_struct(
  input: DescribeLimitsOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.account_max_read_capacity_units {
    option.Some(v) -> [#("AccountMaxReadCapacityUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.account_max_write_capacity_units {
    option.Some(v) -> [#("AccountMaxWriteCapacityUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_max_read_capacity_units {
    option.Some(v) -> [#("TableMaxReadCapacityUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_max_write_capacity_units {
    option.Some(v) -> [#("TableMaxWriteCapacityUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_describe_limits_output_struct_top(
  input: DescribeLimitsOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.account_max_read_capacity_units {
    option.Some(v) -> [#("AccountMaxReadCapacityUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.account_max_write_capacity_units {
    option.Some(v) -> [#("AccountMaxWriteCapacityUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_max_read_capacity_units {
    option.Some(v) -> [#("TableMaxReadCapacityUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_max_write_capacity_units {
    option.Some(v) -> [#("TableMaxWriteCapacityUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_describe_limits_output_struct() -> decode.Decoder(
  DescribeLimitsOutput,
) {
  use <- decode.recursive
  use account_max_read_capacity_units <- decode.optional_field(
    "AccountMaxReadCapacityUnits",
    option.None,
    decode.optional(decode.int),
  )
  use account_max_write_capacity_units <- decode.optional_field(
    "AccountMaxWriteCapacityUnits",
    option.None,
    decode.optional(decode.int),
  )
  use table_max_read_capacity_units <- decode.optional_field(
    "TableMaxReadCapacityUnits",
    option.None,
    decode.optional(decode.int),
  )
  use table_max_write_capacity_units <- decode.optional_field(
    "TableMaxWriteCapacityUnits",
    option.None,
    decode.optional(decode.int),
  )
  decode.success(DescribeLimitsOutput(
    account_max_read_capacity_units: account_max_read_capacity_units,
    account_max_write_capacity_units: account_max_write_capacity_units,
    table_max_read_capacity_units: table_max_read_capacity_units,
    table_max_write_capacity_units: table_max_write_capacity_units,
  ))
}

pub type DescribeTableInput {
  DescribeTableInput(table_name: option.Option(String))
}

pub fn describe_table_input_default() -> DescribeTableInput {
  DescribeTableInput(table_name: option.None)
}

pub fn encode_describe_table_input_struct(
  input: DescribeTableInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_describe_table_input_struct_top(
  input: DescribeTableInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_describe_table_input_struct() -> decode.Decoder(
  DescribeTableInput,
) {
  use <- decode.recursive
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DescribeTableInput(table_name: table_name))
}

pub type DescribeTableOutput {
  DescribeTableOutput(table: option.Option(TableDescription))
}

pub fn describe_table_output_default() -> DescribeTableOutput {
  DescribeTableOutput(table: option.None)
}

pub fn encode_describe_table_output_struct(
  input: DescribeTableOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.table {
    option.Some(v) -> [#("Table", encode_table_description_struct(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_describe_table_output_struct_top(
  input: DescribeTableOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.table {
    option.Some(v) -> [#("Table", encode_table_description_struct(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_describe_table_output_struct() -> decode.Decoder(
  DescribeTableOutput,
) {
  use <- decode.recursive
  use table <- decode.optional_field(
    "Table",
    option.None,
    decode.optional(decode_table_description_struct()),
  )
  decode.success(DescribeTableOutput(table: table))
}

pub type DescribeTableReplicaAutoScalingInput {
  DescribeTableReplicaAutoScalingInput(table_name: option.Option(String))
}

pub fn describe_table_replica_auto_scaling_input_default() -> DescribeTableReplicaAutoScalingInput {
  DescribeTableReplicaAutoScalingInput(table_name: option.None)
}

pub fn encode_describe_table_replica_auto_scaling_input_struct(
  input: DescribeTableReplicaAutoScalingInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_describe_table_replica_auto_scaling_input_struct_top(
  input: DescribeTableReplicaAutoScalingInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_describe_table_replica_auto_scaling_input_struct() -> decode.Decoder(
  DescribeTableReplicaAutoScalingInput,
) {
  use <- decode.recursive
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DescribeTableReplicaAutoScalingInput(table_name: table_name))
}

pub type DescribeTableReplicaAutoScalingOutput {
  DescribeTableReplicaAutoScalingOutput(
    table_auto_scaling_description: option.Option(TableAutoScalingDescription),
  )
}

pub fn describe_table_replica_auto_scaling_output_default() -> DescribeTableReplicaAutoScalingOutput {
  DescribeTableReplicaAutoScalingOutput(
    table_auto_scaling_description: option.None,
  )
}

pub fn encode_describe_table_replica_auto_scaling_output_struct(
  input: DescribeTableReplicaAutoScalingOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.table_auto_scaling_description {
    option.Some(v) -> [
      #(
        "TableAutoScalingDescription",
        encode_table_auto_scaling_description_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_describe_table_replica_auto_scaling_output_struct_top(
  input: DescribeTableReplicaAutoScalingOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.table_auto_scaling_description {
    option.Some(v) -> [
      #(
        "TableAutoScalingDescription",
        encode_table_auto_scaling_description_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_describe_table_replica_auto_scaling_output_struct() -> decode.Decoder(
  DescribeTableReplicaAutoScalingOutput,
) {
  use <- decode.recursive
  use table_auto_scaling_description <- decode.optional_field(
    "TableAutoScalingDescription",
    option.None,
    decode.optional(decode_table_auto_scaling_description_struct()),
  )
  decode.success(DescribeTableReplicaAutoScalingOutput(
    table_auto_scaling_description: table_auto_scaling_description,
  ))
}

pub type TableAutoScalingDescription {
  TableAutoScalingDescription(
    replicas: option.Option(List(ReplicaAutoScalingDescription)),
    table_name: option.Option(String),
    table_status: option.Option(TableStatus),
  )
}

pub fn table_auto_scaling_description_default() -> TableAutoScalingDescription {
  TableAutoScalingDescription(
    replicas: option.None,
    table_name: option.None,
    table_status: option.None,
  )
}

pub fn encode_table_auto_scaling_description_struct(
  input: TableAutoScalingDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.replicas {
    option.Some(v) -> [
      #(
        "Replicas",
        fn(xs) {
          json.array(xs, encode_replica_auto_scaling_description_struct)
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_status {
    option.Some(v) -> [#("TableStatus", encode_table_status_enum(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_table_auto_scaling_description_struct_top(
  input: TableAutoScalingDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.replicas {
    option.Some(v) -> [
      #(
        "Replicas",
        fn(xs) {
          json.array(xs, encode_replica_auto_scaling_description_struct)
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_status {
    option.Some(v) -> [#("TableStatus", encode_table_status_enum(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_table_auto_scaling_description_struct() -> decode.Decoder(
  TableAutoScalingDescription,
) {
  use <- decode.recursive
  use replicas <- decode.optional_field(
    "Replicas",
    option.None,
    decode.optional(
      decode.list(decode_replica_auto_scaling_description_struct()),
    ),
  )
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  use table_status <- decode.optional_field(
    "TableStatus",
    option.None,
    decode.optional(decode_table_status_enum()),
  )
  decode.success(TableAutoScalingDescription(
    replicas: replicas,
    table_name: table_name,
    table_status: table_status,
  ))
}

pub type ReplicaAutoScalingDescription {
  ReplicaAutoScalingDescription(
    global_secondary_indexes: option.Option(
      List(ReplicaGlobalSecondaryIndexAutoScalingDescription),
    ),
    region_name: option.Option(String),
    replica_provisioned_read_capacity_auto_scaling_settings: option.Option(
      AutoScalingSettingsDescription,
    ),
    replica_provisioned_write_capacity_auto_scaling_settings: option.Option(
      AutoScalingSettingsDescription,
    ),
    replica_status: option.Option(ReplicaStatus),
  )
}

pub fn replica_auto_scaling_description_default() -> ReplicaAutoScalingDescription {
  ReplicaAutoScalingDescription(
    global_secondary_indexes: option.None,
    region_name: option.None,
    replica_provisioned_read_capacity_auto_scaling_settings: option.None,
    replica_provisioned_write_capacity_auto_scaling_settings: option.None,
    replica_status: option.None,
  )
}

pub fn encode_replica_auto_scaling_description_struct(
  input: ReplicaAutoScalingDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.global_secondary_indexes {
    option.Some(v) -> [
      #(
        "GlobalSecondaryIndexes",
        fn(xs) {
          json.array(
            xs,
            encode_replica_global_secondary_index_auto_scaling_description_struct,
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.region_name {
    option.Some(v) -> [#("RegionName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case
    input.replica_provisioned_read_capacity_auto_scaling_settings
  {
    option.Some(v) -> [
      #(
        "ReplicaProvisionedReadCapacityAutoScalingSettings",
        encode_auto_scaling_settings_description_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case
    input.replica_provisioned_write_capacity_auto_scaling_settings
  {
    option.Some(v) -> [
      #(
        "ReplicaProvisionedWriteCapacityAutoScalingSettings",
        encode_auto_scaling_settings_description_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.replica_status {
    option.Some(v) -> [
      #("ReplicaStatus", encode_replica_status_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_replica_auto_scaling_description_struct_top(
  input: ReplicaAutoScalingDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.global_secondary_indexes {
    option.Some(v) -> [
      #(
        "GlobalSecondaryIndexes",
        fn(xs) {
          json.array(
            xs,
            encode_replica_global_secondary_index_auto_scaling_description_struct,
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.region_name {
    option.Some(v) -> [#("RegionName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case
    input.replica_provisioned_read_capacity_auto_scaling_settings
  {
    option.Some(v) -> [
      #(
        "ReplicaProvisionedReadCapacityAutoScalingSettings",
        encode_auto_scaling_settings_description_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case
    input.replica_provisioned_write_capacity_auto_scaling_settings
  {
    option.Some(v) -> [
      #(
        "ReplicaProvisionedWriteCapacityAutoScalingSettings",
        encode_auto_scaling_settings_description_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.replica_status {
    option.Some(v) -> [
      #("ReplicaStatus", encode_replica_status_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_replica_auto_scaling_description_struct() -> decode.Decoder(
  ReplicaAutoScalingDescription,
) {
  use <- decode.recursive
  use global_secondary_indexes <- decode.optional_field(
    "GlobalSecondaryIndexes",
    option.None,
    decode.optional(
      decode.list(
        decode_replica_global_secondary_index_auto_scaling_description_struct(),
      ),
    ),
  )
  use region_name <- decode.optional_field(
    "RegionName",
    option.None,
    decode.optional(decode.string),
  )
  use replica_provisioned_read_capacity_auto_scaling_settings <- decode.optional_field(
    "ReplicaProvisionedReadCapacityAutoScalingSettings",
    option.None,
    decode.optional(decode_auto_scaling_settings_description_struct()),
  )
  use replica_provisioned_write_capacity_auto_scaling_settings <- decode.optional_field(
    "ReplicaProvisionedWriteCapacityAutoScalingSettings",
    option.None,
    decode.optional(decode_auto_scaling_settings_description_struct()),
  )
  use replica_status <- decode.optional_field(
    "ReplicaStatus",
    option.None,
    decode.optional(decode_replica_status_enum()),
  )
  decode.success(ReplicaAutoScalingDescription(
    global_secondary_indexes: global_secondary_indexes,
    region_name: region_name,
    replica_provisioned_read_capacity_auto_scaling_settings: replica_provisioned_read_capacity_auto_scaling_settings,
    replica_provisioned_write_capacity_auto_scaling_settings: replica_provisioned_write_capacity_auto_scaling_settings,
    replica_status: replica_status,
  ))
}

pub type ReplicaGlobalSecondaryIndexAutoScalingDescription {
  ReplicaGlobalSecondaryIndexAutoScalingDescription(
    index_name: option.Option(String),
    index_status: option.Option(IndexStatus),
    provisioned_read_capacity_auto_scaling_settings: option.Option(
      AutoScalingSettingsDescription,
    ),
    provisioned_write_capacity_auto_scaling_settings: option.Option(
      AutoScalingSettingsDescription,
    ),
  )
}

pub fn replica_global_secondary_index_auto_scaling_description_default() -> ReplicaGlobalSecondaryIndexAutoScalingDescription {
  ReplicaGlobalSecondaryIndexAutoScalingDescription(
    index_name: option.None,
    index_status: option.None,
    provisioned_read_capacity_auto_scaling_settings: option.None,
    provisioned_write_capacity_auto_scaling_settings: option.None,
  )
}

pub fn encode_replica_global_secondary_index_auto_scaling_description_struct(
  input: ReplicaGlobalSecondaryIndexAutoScalingDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.index_status {
    option.Some(v) -> [#("IndexStatus", encode_index_status_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.provisioned_read_capacity_auto_scaling_settings {
    option.Some(v) -> [
      #(
        "ProvisionedReadCapacityAutoScalingSettings",
        encode_auto_scaling_settings_description_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_write_capacity_auto_scaling_settings {
    option.Some(v) -> [
      #(
        "ProvisionedWriteCapacityAutoScalingSettings",
        encode_auto_scaling_settings_description_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_replica_global_secondary_index_auto_scaling_description_struct_top(
  input: ReplicaGlobalSecondaryIndexAutoScalingDescription,
) -> json.Json {
  let pairs = []
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.index_status {
    option.Some(v) -> [#("IndexStatus", encode_index_status_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.provisioned_read_capacity_auto_scaling_settings {
    option.Some(v) -> [
      #(
        "ProvisionedReadCapacityAutoScalingSettings",
        encode_auto_scaling_settings_description_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_write_capacity_auto_scaling_settings {
    option.Some(v) -> [
      #(
        "ProvisionedWriteCapacityAutoScalingSettings",
        encode_auto_scaling_settings_description_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_replica_global_secondary_index_auto_scaling_description_struct() -> decode.Decoder(
  ReplicaGlobalSecondaryIndexAutoScalingDescription,
) {
  use <- decode.recursive
  use index_name <- decode.optional_field(
    "IndexName",
    option.None,
    decode.optional(decode.string),
  )
  use index_status <- decode.optional_field(
    "IndexStatus",
    option.None,
    decode.optional(decode_index_status_enum()),
  )
  use provisioned_read_capacity_auto_scaling_settings <- decode.optional_field(
    "ProvisionedReadCapacityAutoScalingSettings",
    option.None,
    decode.optional(decode_auto_scaling_settings_description_struct()),
  )
  use provisioned_write_capacity_auto_scaling_settings <- decode.optional_field(
    "ProvisionedWriteCapacityAutoScalingSettings",
    option.None,
    decode.optional(decode_auto_scaling_settings_description_struct()),
  )
  decode.success(ReplicaGlobalSecondaryIndexAutoScalingDescription(
    index_name: index_name,
    index_status: index_status,
    provisioned_read_capacity_auto_scaling_settings: provisioned_read_capacity_auto_scaling_settings,
    provisioned_write_capacity_auto_scaling_settings: provisioned_write_capacity_auto_scaling_settings,
  ))
}

pub type DescribeTimeToLiveInput {
  DescribeTimeToLiveInput(table_name: option.Option(String))
}

pub fn describe_time_to_live_input_default() -> DescribeTimeToLiveInput {
  DescribeTimeToLiveInput(table_name: option.None)
}

pub fn encode_describe_time_to_live_input_struct(
  input: DescribeTimeToLiveInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_describe_time_to_live_input_struct_top(
  input: DescribeTimeToLiveInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_describe_time_to_live_input_struct() -> decode.Decoder(
  DescribeTimeToLiveInput,
) {
  use <- decode.recursive
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DescribeTimeToLiveInput(table_name: table_name))
}

pub type DescribeTimeToLiveOutput {
  DescribeTimeToLiveOutput(
    time_to_live_description: option.Option(TimeToLiveDescription),
  )
}

pub fn describe_time_to_live_output_default() -> DescribeTimeToLiveOutput {
  DescribeTimeToLiveOutput(time_to_live_description: option.None)
}

pub fn encode_describe_time_to_live_output_struct(
  input: DescribeTimeToLiveOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.time_to_live_description {
    option.Some(v) -> [
      #("TimeToLiveDescription", encode_time_to_live_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_describe_time_to_live_output_struct_top(
  input: DescribeTimeToLiveOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.time_to_live_description {
    option.Some(v) -> [
      #("TimeToLiveDescription", encode_time_to_live_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_describe_time_to_live_output_struct() -> decode.Decoder(
  DescribeTimeToLiveOutput,
) {
  use <- decode.recursive
  use time_to_live_description <- decode.optional_field(
    "TimeToLiveDescription",
    option.None,
    decode.optional(decode_time_to_live_description_struct()),
  )
  decode.success(DescribeTimeToLiveOutput(
    time_to_live_description: time_to_live_description,
  ))
}

pub type KinesisStreamingDestinationInput {
  KinesisStreamingDestinationInput(
    enable_kinesis_streaming_configuration: option.Option(
      EnableKinesisStreamingConfiguration,
    ),
    stream_arn: option.Option(String),
    table_name: option.Option(String),
  )
}

pub fn kinesis_streaming_destination_input_default() -> KinesisStreamingDestinationInput {
  KinesisStreamingDestinationInput(
    enable_kinesis_streaming_configuration: option.None,
    stream_arn: option.None,
    table_name: option.None,
  )
}

pub fn encode_kinesis_streaming_destination_input_struct(
  input: KinesisStreamingDestinationInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.enable_kinesis_streaming_configuration {
    option.Some(v) -> [
      #(
        "EnableKinesisStreamingConfiguration",
        encode_enable_kinesis_streaming_configuration_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.stream_arn {
    option.Some(v) -> [#("StreamArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_kinesis_streaming_destination_input_struct_top(
  input: KinesisStreamingDestinationInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.enable_kinesis_streaming_configuration {
    option.Some(v) -> [
      #(
        "EnableKinesisStreamingConfiguration",
        encode_enable_kinesis_streaming_configuration_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.stream_arn {
    option.Some(v) -> [#("StreamArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_kinesis_streaming_destination_input_struct() -> decode.Decoder(
  KinesisStreamingDestinationInput,
) {
  use <- decode.recursive
  use enable_kinesis_streaming_configuration <- decode.optional_field(
    "EnableKinesisStreamingConfiguration",
    option.None,
    decode.optional(decode_enable_kinesis_streaming_configuration_struct()),
  )
  use stream_arn <- decode.optional_field(
    "StreamArn",
    option.None,
    decode.optional(decode.string),
  )
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(KinesisStreamingDestinationInput(
    enable_kinesis_streaming_configuration: enable_kinesis_streaming_configuration,
    stream_arn: stream_arn,
    table_name: table_name,
  ))
}

pub type EnableKinesisStreamingConfiguration {
  EnableKinesisStreamingConfiguration(
    approximate_creation_date_time_precision: option.Option(
      ApproximateCreationDateTimePrecision,
    ),
  )
}

pub fn enable_kinesis_streaming_configuration_default() -> EnableKinesisStreamingConfiguration {
  EnableKinesisStreamingConfiguration(
    approximate_creation_date_time_precision: option.None,
  )
}

pub fn encode_enable_kinesis_streaming_configuration_struct(
  input: EnableKinesisStreamingConfiguration,
) -> json.Json {
  let pairs = []
  let pairs = case input.approximate_creation_date_time_precision {
    option.Some(v) -> [
      #(
        "ApproximateCreationDateTimePrecision",
        encode_approximate_creation_date_time_precision_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_enable_kinesis_streaming_configuration_struct_top(
  input: EnableKinesisStreamingConfiguration,
) -> json.Json {
  let pairs = []
  let pairs = case input.approximate_creation_date_time_precision {
    option.Some(v) -> [
      #(
        "ApproximateCreationDateTimePrecision",
        encode_approximate_creation_date_time_precision_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_enable_kinesis_streaming_configuration_struct() -> decode.Decoder(
  EnableKinesisStreamingConfiguration,
) {
  use <- decode.recursive
  use approximate_creation_date_time_precision <- decode.optional_field(
    "ApproximateCreationDateTimePrecision",
    option.None,
    decode.optional(decode_approximate_creation_date_time_precision_enum()),
  )
  decode.success(EnableKinesisStreamingConfiguration(
    approximate_creation_date_time_precision: approximate_creation_date_time_precision,
  ))
}

pub type KinesisStreamingDestinationOutput {
  KinesisStreamingDestinationOutput(
    destination_status: option.Option(DestinationStatus),
    enable_kinesis_streaming_configuration: option.Option(
      EnableKinesisStreamingConfiguration,
    ),
    stream_arn: option.Option(String),
    table_name: option.Option(String),
  )
}

pub fn kinesis_streaming_destination_output_default() -> KinesisStreamingDestinationOutput {
  KinesisStreamingDestinationOutput(
    destination_status: option.None,
    enable_kinesis_streaming_configuration: option.None,
    stream_arn: option.None,
    table_name: option.None,
  )
}

pub fn encode_kinesis_streaming_destination_output_struct(
  input: KinesisStreamingDestinationOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.destination_status {
    option.Some(v) -> [
      #("DestinationStatus", encode_destination_status_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.enable_kinesis_streaming_configuration {
    option.Some(v) -> [
      #(
        "EnableKinesisStreamingConfiguration",
        encode_enable_kinesis_streaming_configuration_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.stream_arn {
    option.Some(v) -> [#("StreamArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_kinesis_streaming_destination_output_struct_top(
  input: KinesisStreamingDestinationOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.destination_status {
    option.Some(v) -> [
      #("DestinationStatus", encode_destination_status_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.enable_kinesis_streaming_configuration {
    option.Some(v) -> [
      #(
        "EnableKinesisStreamingConfiguration",
        encode_enable_kinesis_streaming_configuration_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.stream_arn {
    option.Some(v) -> [#("StreamArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_kinesis_streaming_destination_output_struct() -> decode.Decoder(
  KinesisStreamingDestinationOutput,
) {
  use <- decode.recursive
  use destination_status <- decode.optional_field(
    "DestinationStatus",
    option.None,
    decode.optional(decode_destination_status_enum()),
  )
  use enable_kinesis_streaming_configuration <- decode.optional_field(
    "EnableKinesisStreamingConfiguration",
    option.None,
    decode.optional(decode_enable_kinesis_streaming_configuration_struct()),
  )
  use stream_arn <- decode.optional_field(
    "StreamArn",
    option.None,
    decode.optional(decode.string),
  )
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(KinesisStreamingDestinationOutput(
    destination_status: destination_status,
    enable_kinesis_streaming_configuration: enable_kinesis_streaming_configuration,
    stream_arn: stream_arn,
    table_name: table_name,
  ))
}

pub type ExecuteStatementInput {
  ExecuteStatementInput(
    consistent_read: option.Option(Bool),
    limit: option.Option(Int),
    next_token: option.Option(String),
    parameters: option.Option(List(AttributeValue)),
    return_consumed_capacity: option.Option(ReturnConsumedCapacity),
    return_values_on_condition_check_failure: option.Option(
      ReturnValuesOnConditionCheckFailure,
    ),
    statement: option.Option(String),
  )
}

pub fn execute_statement_input_default() -> ExecuteStatementInput {
  ExecuteStatementInput(
    consistent_read: option.None,
    limit: option.None,
    next_token: option.None,
    parameters: option.None,
    return_consumed_capacity: option.None,
    return_values_on_condition_check_failure: option.None,
    statement: option.None,
  )
}

pub fn encode_execute_statement_input_struct(
  input: ExecuteStatementInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.consistent_read {
    option.Some(v) -> [#("ConsistentRead", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.limit {
    option.Some(v) -> [#("Limit", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.next_token {
    option.Some(v) -> [#("NextToken", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.parameters {
    option.Some(v) -> [
      #(
        "Parameters",
        fn(xs) { json.array(xs, encode_attribute_value_union) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_consumed_capacity {
    option.Some(v) -> [
      #("ReturnConsumedCapacity", encode_return_consumed_capacity_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_values_on_condition_check_failure {
    option.Some(v) -> [
      #(
        "ReturnValuesOnConditionCheckFailure",
        encode_return_values_on_condition_check_failure_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.statement {
    option.Some(v) -> [#("Statement", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_execute_statement_input_struct_top(
  input: ExecuteStatementInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.consistent_read {
    option.Some(v) -> [#("ConsistentRead", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.limit {
    option.Some(v) -> [#("Limit", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.next_token {
    option.Some(v) -> [#("NextToken", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.parameters {
    option.Some(v) -> [
      #(
        "Parameters",
        fn(xs) { json.array(xs, encode_attribute_value_union) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_consumed_capacity {
    option.Some(v) -> [
      #("ReturnConsumedCapacity", encode_return_consumed_capacity_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_values_on_condition_check_failure {
    option.Some(v) -> [
      #(
        "ReturnValuesOnConditionCheckFailure",
        encode_return_values_on_condition_check_failure_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.statement {
    option.Some(v) -> [#("Statement", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_execute_statement_input_struct() -> decode.Decoder(
  ExecuteStatementInput,
) {
  use <- decode.recursive
  use consistent_read <- decode.optional_field(
    "ConsistentRead",
    option.None,
    decode.optional(decode.bool),
  )
  use limit <- decode.optional_field(
    "Limit",
    option.None,
    decode.optional(decode.int),
  )
  use next_token <- decode.optional_field(
    "NextToken",
    option.None,
    decode.optional(decode.string),
  )
  use parameters <- decode.optional_field(
    "Parameters",
    option.None,
    decode.optional(decode.list(decode_attribute_value_union())),
  )
  use return_consumed_capacity <- decode.optional_field(
    "ReturnConsumedCapacity",
    option.None,
    decode.optional(decode_return_consumed_capacity_enum()),
  )
  use return_values_on_condition_check_failure <- decode.optional_field(
    "ReturnValuesOnConditionCheckFailure",
    option.None,
    decode.optional(decode_return_values_on_condition_check_failure_enum()),
  )
  use statement <- decode.optional_field(
    "Statement",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ExecuteStatementInput(
    consistent_read: consistent_read,
    limit: limit,
    next_token: next_token,
    parameters: parameters,
    return_consumed_capacity: return_consumed_capacity,
    return_values_on_condition_check_failure: return_values_on_condition_check_failure,
    statement: statement,
  ))
}

pub type ExecuteStatementOutput {
  ExecuteStatementOutput(
    consumed_capacity: option.Option(ConsumedCapacity),
    items: option.Option(List(dict.Dict(String, AttributeValue))),
    last_evaluated_key: option.Option(dict.Dict(String, AttributeValue)),
    next_token: option.Option(String),
  )
}

pub fn execute_statement_output_default() -> ExecuteStatementOutput {
  ExecuteStatementOutput(
    consumed_capacity: option.None,
    items: option.None,
    last_evaluated_key: option.None,
    next_token: option.None,
  )
}

pub fn encode_execute_statement_output_struct(
  input: ExecuteStatementOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.consumed_capacity {
    option.Some(v) -> [
      #("ConsumedCapacity", encode_consumed_capacity_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.items {
    option.Some(v) -> [
      #(
        "Items",
        fn(xs) {
          json.array(xs, fn(d) {
            json.object(
              dict.to_list(d)
              |> list.map(fn(pair) {
                #(pair.0, encode_attribute_value_union(pair.1))
              }),
            )
          })
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.last_evaluated_key {
    option.Some(v) -> [
      #(
        "LastEvaluatedKey",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.next_token {
    option.Some(v) -> [#("NextToken", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_execute_statement_output_struct_top(
  input: ExecuteStatementOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.consumed_capacity {
    option.Some(v) -> [
      #("ConsumedCapacity", encode_consumed_capacity_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.items {
    option.Some(v) -> [
      #(
        "Items",
        fn(xs) {
          json.array(xs, fn(d) {
            json.object(
              dict.to_list(d)
              |> list.map(fn(pair) {
                #(pair.0, encode_attribute_value_union(pair.1))
              }),
            )
          })
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.last_evaluated_key {
    option.Some(v) -> [
      #(
        "LastEvaluatedKey",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.next_token {
    option.Some(v) -> [#("NextToken", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_execute_statement_output_struct() -> decode.Decoder(
  ExecuteStatementOutput,
) {
  use <- decode.recursive
  use consumed_capacity <- decode.optional_field(
    "ConsumedCapacity",
    option.None,
    decode.optional(decode_consumed_capacity_struct()),
  )
  use items <- decode.optional_field(
    "Items",
    option.None,
    decode.optional(
      decode.list(decode.dict(decode.string, decode_attribute_value_union())),
    ),
  )
  use last_evaluated_key <- decode.optional_field(
    "LastEvaluatedKey",
    option.None,
    decode.optional(decode.dict(decode.string, decode_attribute_value_union())),
  )
  use next_token <- decode.optional_field(
    "NextToken",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ExecuteStatementOutput(
    consumed_capacity: consumed_capacity,
    items: items,
    last_evaluated_key: last_evaluated_key,
    next_token: next_token,
  ))
}

pub type DuplicateItemException {
  DuplicateItemException(message: option.Option(String))
}

pub fn duplicate_item_exception_default() -> DuplicateItemException {
  DuplicateItemException(message: option.None)
}

pub fn encode_duplicate_item_exception_struct(
  input: DuplicateItemException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_duplicate_item_exception_struct_top(
  input: DuplicateItemException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_duplicate_item_exception_struct() -> decode.Decoder(
  DuplicateItemException,
) {
  use <- decode.recursive
  use message <- decode.optional_field(
    "message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DuplicateItemException(message: message))
}

pub type ExecuteTransactionInput {
  ExecuteTransactionInput(
    client_request_token: option.Option(String),
    return_consumed_capacity: option.Option(ReturnConsumedCapacity),
    transact_statements: option.Option(List(ParameterizedStatement)),
  )
}

pub fn execute_transaction_input_default() -> ExecuteTransactionInput {
  ExecuteTransactionInput(
    client_request_token: option.None,
    return_consumed_capacity: option.None,
    transact_statements: option.None,
  )
}

pub fn encode_execute_transaction_input_struct(
  input: ExecuteTransactionInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.client_request_token {
    option.Some(v) -> [#("ClientRequestToken", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.return_consumed_capacity {
    option.Some(v) -> [
      #("ReturnConsumedCapacity", encode_return_consumed_capacity_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.transact_statements {
    option.Some(v) -> [
      #(
        "TransactStatements",
        fn(xs) { json.array(xs, encode_parameterized_statement_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_execute_transaction_input_struct_top(
  input: ExecuteTransactionInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.client_request_token {
    option.Some(v) -> [#("ClientRequestToken", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.return_consumed_capacity {
    option.Some(v) -> [
      #("ReturnConsumedCapacity", encode_return_consumed_capacity_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.transact_statements {
    option.Some(v) -> [
      #(
        "TransactStatements",
        fn(xs) { json.array(xs, encode_parameterized_statement_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_execute_transaction_input_struct() -> decode.Decoder(
  ExecuteTransactionInput,
) {
  use <- decode.recursive
  use client_request_token <- decode.optional_field(
    "ClientRequestToken",
    option.None,
    decode.optional(decode.string),
  )
  use return_consumed_capacity <- decode.optional_field(
    "ReturnConsumedCapacity",
    option.None,
    decode.optional(decode_return_consumed_capacity_enum()),
  )
  use transact_statements <- decode.optional_field(
    "TransactStatements",
    option.None,
    decode.optional(decode.list(decode_parameterized_statement_struct())),
  )
  decode.success(ExecuteTransactionInput(
    client_request_token: client_request_token,
    return_consumed_capacity: return_consumed_capacity,
    transact_statements: transact_statements,
  ))
}

pub type ParameterizedStatement {
  ParameterizedStatement(
    parameters: option.Option(List(AttributeValue)),
    return_values_on_condition_check_failure: option.Option(
      ReturnValuesOnConditionCheckFailure,
    ),
    statement: option.Option(String),
  )
}

pub fn parameterized_statement_default() -> ParameterizedStatement {
  ParameterizedStatement(
    parameters: option.None,
    return_values_on_condition_check_failure: option.None,
    statement: option.None,
  )
}

pub fn encode_parameterized_statement_struct(
  input: ParameterizedStatement,
) -> json.Json {
  let pairs = []
  let pairs = case input.parameters {
    option.Some(v) -> [
      #(
        "Parameters",
        fn(xs) { json.array(xs, encode_attribute_value_union) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_values_on_condition_check_failure {
    option.Some(v) -> [
      #(
        "ReturnValuesOnConditionCheckFailure",
        encode_return_values_on_condition_check_failure_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.statement {
    option.Some(v) -> [#("Statement", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_parameterized_statement_struct_top(
  input: ParameterizedStatement,
) -> json.Json {
  let pairs = []
  let pairs = case input.parameters {
    option.Some(v) -> [
      #(
        "Parameters",
        fn(xs) { json.array(xs, encode_attribute_value_union) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_values_on_condition_check_failure {
    option.Some(v) -> [
      #(
        "ReturnValuesOnConditionCheckFailure",
        encode_return_values_on_condition_check_failure_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.statement {
    option.Some(v) -> [#("Statement", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_parameterized_statement_struct() -> decode.Decoder(
  ParameterizedStatement,
) {
  use <- decode.recursive
  use parameters <- decode.optional_field(
    "Parameters",
    option.None,
    decode.optional(decode.list(decode_attribute_value_union())),
  )
  use return_values_on_condition_check_failure <- decode.optional_field(
    "ReturnValuesOnConditionCheckFailure",
    option.None,
    decode.optional(decode_return_values_on_condition_check_failure_enum()),
  )
  use statement <- decode.optional_field(
    "Statement",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ParameterizedStatement(
    parameters: parameters,
    return_values_on_condition_check_failure: return_values_on_condition_check_failure,
    statement: statement,
  ))
}

pub type ExecuteTransactionOutput {
  ExecuteTransactionOutput(
    consumed_capacity: option.Option(List(ConsumedCapacity)),
    responses: option.Option(List(ItemResponse)),
  )
}

pub fn execute_transaction_output_default() -> ExecuteTransactionOutput {
  ExecuteTransactionOutput(
    consumed_capacity: option.None,
    responses: option.None,
  )
}

pub fn encode_execute_transaction_output_struct(
  input: ExecuteTransactionOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.consumed_capacity {
    option.Some(v) -> [
      #(
        "ConsumedCapacity",
        fn(xs) { json.array(xs, encode_consumed_capacity_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.responses {
    option.Some(v) -> [
      #("Responses", fn(xs) { json.array(xs, encode_item_response_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_execute_transaction_output_struct_top(
  input: ExecuteTransactionOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.consumed_capacity {
    option.Some(v) -> [
      #(
        "ConsumedCapacity",
        fn(xs) { json.array(xs, encode_consumed_capacity_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.responses {
    option.Some(v) -> [
      #("Responses", fn(xs) { json.array(xs, encode_item_response_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_execute_transaction_output_struct() -> decode.Decoder(
  ExecuteTransactionOutput,
) {
  use <- decode.recursive
  use consumed_capacity <- decode.optional_field(
    "ConsumedCapacity",
    option.None,
    decode.optional(decode.list(decode_consumed_capacity_struct())),
  )
  use responses <- decode.optional_field(
    "Responses",
    option.None,
    decode.optional(decode.list(decode_item_response_struct())),
  )
  decode.success(ExecuteTransactionOutput(
    consumed_capacity: consumed_capacity,
    responses: responses,
  ))
}

pub type ItemResponse {
  ItemResponse(item: option.Option(dict.Dict(String, AttributeValue)))
}

pub fn item_response_default() -> ItemResponse {
  ItemResponse(item: option.None)
}

pub fn encode_item_response_struct(input: ItemResponse) -> json.Json {
  let pairs = []
  let pairs = case input.item {
    option.Some(v) -> [
      #(
        "Item",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_item_response_struct_top(input: ItemResponse) -> json.Json {
  let pairs = []
  let pairs = case input.item {
    option.Some(v) -> [
      #(
        "Item",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_item_response_struct() -> decode.Decoder(ItemResponse) {
  use <- decode.recursive
  use item <- decode.optional_field(
    "Item",
    option.None,
    decode.optional(decode.dict(decode.string, decode_attribute_value_union())),
  )
  decode.success(ItemResponse(item: item))
}

pub type IdempotentParameterMismatchException {
  IdempotentParameterMismatchException(message: option.Option(String))
}

pub fn idempotent_parameter_mismatch_exception_default() -> IdempotentParameterMismatchException {
  IdempotentParameterMismatchException(message: option.None)
}

pub fn encode_idempotent_parameter_mismatch_exception_struct(
  input: IdempotentParameterMismatchException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("Message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_idempotent_parameter_mismatch_exception_struct_top(
  input: IdempotentParameterMismatchException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("Message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_idempotent_parameter_mismatch_exception_struct() -> decode.Decoder(
  IdempotentParameterMismatchException,
) {
  use <- decode.recursive
  use message <- decode.optional_field(
    "Message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(IdempotentParameterMismatchException(message: message))
}

pub type TransactionCanceledException {
  TransactionCanceledException(
    cancellation_reasons: option.Option(List(CancellationReason)),
    message: option.Option(String),
  )
}

pub fn transaction_canceled_exception_default() -> TransactionCanceledException {
  TransactionCanceledException(
    cancellation_reasons: option.None,
    message: option.None,
  )
}

pub fn encode_transaction_canceled_exception_struct(
  input: TransactionCanceledException,
) -> json.Json {
  let pairs = []
  let pairs = case input.cancellation_reasons {
    option.Some(v) -> [
      #(
        "CancellationReasons",
        fn(xs) { json.array(xs, encode_cancellation_reason_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.message {
    option.Some(v) -> [#("Message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_transaction_canceled_exception_struct_top(
  input: TransactionCanceledException,
) -> json.Json {
  let pairs = []
  let pairs = case input.cancellation_reasons {
    option.Some(v) -> [
      #(
        "CancellationReasons",
        fn(xs) { json.array(xs, encode_cancellation_reason_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.message {
    option.Some(v) -> [#("Message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_transaction_canceled_exception_struct() -> decode.Decoder(
  TransactionCanceledException,
) {
  use <- decode.recursive
  use cancellation_reasons <- decode.optional_field(
    "CancellationReasons",
    option.None,
    decode.optional(decode.list(decode_cancellation_reason_struct())),
  )
  use message <- decode.optional_field(
    "Message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(TransactionCanceledException(
    cancellation_reasons: cancellation_reasons,
    message: message,
  ))
}

pub type CancellationReason {
  CancellationReason(
    code: option.Option(String),
    item: option.Option(dict.Dict(String, AttributeValue)),
    message: option.Option(String),
  )
}

pub fn cancellation_reason_default() -> CancellationReason {
  CancellationReason(code: option.None, item: option.None, message: option.None)
}

pub fn encode_cancellation_reason_struct(
  input: CancellationReason,
) -> json.Json {
  let pairs = []
  let pairs = case input.code {
    option.Some(v) -> [#("Code", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.item {
    option.Some(v) -> [
      #(
        "Item",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.message {
    option.Some(v) -> [#("Message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_cancellation_reason_struct_top(
  input: CancellationReason,
) -> json.Json {
  let pairs = []
  let pairs = case input.code {
    option.Some(v) -> [#("Code", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.item {
    option.Some(v) -> [
      #(
        "Item",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.message {
    option.Some(v) -> [#("Message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_cancellation_reason_struct() -> decode.Decoder(CancellationReason) {
  use <- decode.recursive
  use code <- decode.optional_field(
    "Code",
    option.None,
    decode.optional(decode.string),
  )
  use item <- decode.optional_field(
    "Item",
    option.None,
    decode.optional(decode.dict(decode.string, decode_attribute_value_union())),
  )
  use message <- decode.optional_field(
    "Message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(CancellationReason(code: code, item: item, message: message))
}

pub type TransactionInProgressException {
  TransactionInProgressException(message: option.Option(String))
}

pub fn transaction_in_progress_exception_default() -> TransactionInProgressException {
  TransactionInProgressException(message: option.None)
}

pub fn encode_transaction_in_progress_exception_struct(
  input: TransactionInProgressException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("Message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_transaction_in_progress_exception_struct_top(
  input: TransactionInProgressException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("Message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_transaction_in_progress_exception_struct() -> decode.Decoder(
  TransactionInProgressException,
) {
  use <- decode.recursive
  use message <- decode.optional_field(
    "Message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(TransactionInProgressException(message: message))
}

pub type ExportTableToPointInTimeInput {
  ExportTableToPointInTimeInput(
    client_token: option.Option(String),
    export_format: option.Option(ExportFormat),
    export_time: option.Option(json_timestamp.Timestamp),
    export_type: option.Option(ExportType),
    incremental_export_specification: option.Option(
      IncrementalExportSpecification,
    ),
    s3_bucket: option.Option(String),
    s3_bucket_owner: option.Option(String),
    s3_prefix: option.Option(String),
    s3_sse_algorithm: option.Option(S3SseAlgorithm),
    s3_sse_kms_key_id: option.Option(String),
    table_arn: option.Option(String),
  )
}

pub fn export_table_to_point_in_time_input_default() -> ExportTableToPointInTimeInput {
  ExportTableToPointInTimeInput(
    client_token: option.None,
    export_format: option.None,
    export_time: option.None,
    export_type: option.None,
    incremental_export_specification: option.None,
    s3_bucket: option.None,
    s3_bucket_owner: option.None,
    s3_prefix: option.None,
    s3_sse_algorithm: option.None,
    s3_sse_kms_key_id: option.None,
    table_arn: option.None,
  )
}

pub fn encode_export_table_to_point_in_time_input_struct(
  input: ExportTableToPointInTimeInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.client_token {
    option.Some(v) -> [#("ClientToken", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.export_format {
    option.Some(v) -> [#("ExportFormat", encode_export_format_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.export_time {
    option.Some(v) -> [
      #("ExportTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.export_type {
    option.Some(v) -> [#("ExportType", encode_export_type_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.incremental_export_specification {
    option.Some(v) -> [
      #(
        "IncrementalExportSpecification",
        encode_incremental_export_specification_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.s3_bucket {
    option.Some(v) -> [#("S3Bucket", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.s3_bucket_owner {
    option.Some(v) -> [#("S3BucketOwner", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.s3_prefix {
    option.Some(v) -> [#("S3Prefix", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.s3_sse_algorithm {
    option.Some(v) -> [
      #("S3SseAlgorithm", encode_s3_sse_algorithm_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.s3_sse_kms_key_id {
    option.Some(v) -> [#("S3SseKmsKeyId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_arn {
    option.Some(v) -> [#("TableArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_export_table_to_point_in_time_input_struct_top(
  input: ExportTableToPointInTimeInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.client_token {
    option.Some(v) -> [#("ClientToken", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.export_format {
    option.Some(v) -> [#("ExportFormat", encode_export_format_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.export_time {
    option.Some(v) -> [
      #("ExportTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.export_type {
    option.Some(v) -> [#("ExportType", encode_export_type_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.incremental_export_specification {
    option.Some(v) -> [
      #(
        "IncrementalExportSpecification",
        encode_incremental_export_specification_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.s3_bucket {
    option.Some(v) -> [#("S3Bucket", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.s3_bucket_owner {
    option.Some(v) -> [#("S3BucketOwner", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.s3_prefix {
    option.Some(v) -> [#("S3Prefix", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.s3_sse_algorithm {
    option.Some(v) -> [
      #("S3SseAlgorithm", encode_s3_sse_algorithm_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.s3_sse_kms_key_id {
    option.Some(v) -> [#("S3SseKmsKeyId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_arn {
    option.Some(v) -> [#("TableArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_export_table_to_point_in_time_input_struct() -> decode.Decoder(
  ExportTableToPointInTimeInput,
) {
  use <- decode.recursive
  use client_token <- decode.optional_field(
    "ClientToken",
    option.None,
    decode.optional(decode.string),
  )
  use export_format <- decode.optional_field(
    "ExportFormat",
    option.None,
    decode.optional(decode_export_format_enum()),
  )
  use export_time <- decode.optional_field(
    "ExportTime",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use export_type <- decode.optional_field(
    "ExportType",
    option.None,
    decode.optional(decode_export_type_enum()),
  )
  use incremental_export_specification <- decode.optional_field(
    "IncrementalExportSpecification",
    option.None,
    decode.optional(decode_incremental_export_specification_struct()),
  )
  use s3_bucket <- decode.optional_field(
    "S3Bucket",
    option.None,
    decode.optional(decode.string),
  )
  use s3_bucket_owner <- decode.optional_field(
    "S3BucketOwner",
    option.None,
    decode.optional(decode.string),
  )
  use s3_prefix <- decode.optional_field(
    "S3Prefix",
    option.None,
    decode.optional(decode.string),
  )
  use s3_sse_algorithm <- decode.optional_field(
    "S3SseAlgorithm",
    option.None,
    decode.optional(decode_s3_sse_algorithm_enum()),
  )
  use s3_sse_kms_key_id <- decode.optional_field(
    "S3SseKmsKeyId",
    option.None,
    decode.optional(decode.string),
  )
  use table_arn <- decode.optional_field(
    "TableArn",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ExportTableToPointInTimeInput(
    client_token: client_token,
    export_format: export_format,
    export_time: export_time,
    export_type: export_type,
    incremental_export_specification: incremental_export_specification,
    s3_bucket: s3_bucket,
    s3_bucket_owner: s3_bucket_owner,
    s3_prefix: s3_prefix,
    s3_sse_algorithm: s3_sse_algorithm,
    s3_sse_kms_key_id: s3_sse_kms_key_id,
    table_arn: table_arn,
  ))
}

pub type ExportTableToPointInTimeOutput {
  ExportTableToPointInTimeOutput(
    export_description: option.Option(ExportDescription),
  )
}

pub fn export_table_to_point_in_time_output_default() -> ExportTableToPointInTimeOutput {
  ExportTableToPointInTimeOutput(export_description: option.None)
}

pub fn encode_export_table_to_point_in_time_output_struct(
  input: ExportTableToPointInTimeOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.export_description {
    option.Some(v) -> [
      #("ExportDescription", encode_export_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_export_table_to_point_in_time_output_struct_top(
  input: ExportTableToPointInTimeOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.export_description {
    option.Some(v) -> [
      #("ExportDescription", encode_export_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_export_table_to_point_in_time_output_struct() -> decode.Decoder(
  ExportTableToPointInTimeOutput,
) {
  use <- decode.recursive
  use export_description <- decode.optional_field(
    "ExportDescription",
    option.None,
    decode.optional(decode_export_description_struct()),
  )
  decode.success(ExportTableToPointInTimeOutput(
    export_description: export_description,
  ))
}

pub type ExportConflictException {
  ExportConflictException(message: option.Option(String))
}

pub fn export_conflict_exception_default() -> ExportConflictException {
  ExportConflictException(message: option.None)
}

pub fn encode_export_conflict_exception_struct(
  input: ExportConflictException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_export_conflict_exception_struct_top(
  input: ExportConflictException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_export_conflict_exception_struct() -> decode.Decoder(
  ExportConflictException,
) {
  use <- decode.recursive
  use message <- decode.optional_field(
    "message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ExportConflictException(message: message))
}

pub type InvalidExportTimeException {
  InvalidExportTimeException(message: option.Option(String))
}

pub fn invalid_export_time_exception_default() -> InvalidExportTimeException {
  InvalidExportTimeException(message: option.None)
}

pub fn encode_invalid_export_time_exception_struct(
  input: InvalidExportTimeException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_invalid_export_time_exception_struct_top(
  input: InvalidExportTimeException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_invalid_export_time_exception_struct() -> decode.Decoder(
  InvalidExportTimeException,
) {
  use <- decode.recursive
  use message <- decode.optional_field(
    "message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(InvalidExportTimeException(message: message))
}

pub type PointInTimeRecoveryUnavailableException {
  PointInTimeRecoveryUnavailableException(message: option.Option(String))
}

pub fn point_in_time_recovery_unavailable_exception_default() -> PointInTimeRecoveryUnavailableException {
  PointInTimeRecoveryUnavailableException(message: option.None)
}

pub fn encode_point_in_time_recovery_unavailable_exception_struct(
  input: PointInTimeRecoveryUnavailableException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_point_in_time_recovery_unavailable_exception_struct_top(
  input: PointInTimeRecoveryUnavailableException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_point_in_time_recovery_unavailable_exception_struct() -> decode.Decoder(
  PointInTimeRecoveryUnavailableException,
) {
  use <- decode.recursive
  use message <- decode.optional_field(
    "message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(PointInTimeRecoveryUnavailableException(message: message))
}

pub type GetItemInput {
  GetItemInput(
    attributes_to_get: option.Option(List(String)),
    consistent_read: option.Option(Bool),
    expression_attribute_names: option.Option(dict.Dict(String, String)),
    key: option.Option(dict.Dict(String, AttributeValue)),
    projection_expression: option.Option(String),
    return_consumed_capacity: option.Option(ReturnConsumedCapacity),
    table_name: option.Option(String),
  )
}

pub fn get_item_input_default() -> GetItemInput {
  GetItemInput(
    attributes_to_get: option.None,
    consistent_read: option.None,
    expression_attribute_names: option.None,
    key: option.None,
    projection_expression: option.None,
    return_consumed_capacity: option.None,
    table_name: option.None,
  )
}

pub fn encode_get_item_input_struct(input: GetItemInput) -> json.Json {
  let pairs = []
  let pairs = case input.attributes_to_get {
    option.Some(v) -> [
      #("AttributesToGet", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.consistent_read {
    option.Some(v) -> [#("ConsistentRead", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_names {
    option.Some(v) -> [
      #(
        "ExpressionAttributeNames",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.key {
    option.Some(v) -> [
      #(
        "Key",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.projection_expression {
    option.Some(v) -> [#("ProjectionExpression", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.return_consumed_capacity {
    option.Some(v) -> [
      #("ReturnConsumedCapacity", encode_return_consumed_capacity_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_get_item_input_struct_top(input: GetItemInput) -> json.Json {
  let pairs = []
  let pairs = case input.attributes_to_get {
    option.Some(v) -> [
      #("AttributesToGet", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.consistent_read {
    option.Some(v) -> [#("ConsistentRead", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_names {
    option.Some(v) -> [
      #(
        "ExpressionAttributeNames",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.key {
    option.Some(v) -> [
      #(
        "Key",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.projection_expression {
    option.Some(v) -> [#("ProjectionExpression", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.return_consumed_capacity {
    option.Some(v) -> [
      #("ReturnConsumedCapacity", encode_return_consumed_capacity_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_item_input_struct() -> decode.Decoder(GetItemInput) {
  use <- decode.recursive
  use attributes_to_get <- decode.optional_field(
    "AttributesToGet",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  use consistent_read <- decode.optional_field(
    "ConsistentRead",
    option.None,
    decode.optional(decode.bool),
  )
  use expression_attribute_names <- decode.optional_field(
    "ExpressionAttributeNames",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use key <- decode.optional_field(
    "Key",
    option.None,
    decode.optional(decode.dict(decode.string, decode_attribute_value_union())),
  )
  use projection_expression <- decode.optional_field(
    "ProjectionExpression",
    option.None,
    decode.optional(decode.string),
  )
  use return_consumed_capacity <- decode.optional_field(
    "ReturnConsumedCapacity",
    option.None,
    decode.optional(decode_return_consumed_capacity_enum()),
  )
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetItemInput(
    attributes_to_get: attributes_to_get,
    consistent_read: consistent_read,
    expression_attribute_names: expression_attribute_names,
    key: key,
    projection_expression: projection_expression,
    return_consumed_capacity: return_consumed_capacity,
    table_name: table_name,
  ))
}

pub type GetItemOutput {
  GetItemOutput(
    consumed_capacity: option.Option(ConsumedCapacity),
    item: option.Option(dict.Dict(String, AttributeValue)),
  )
}

pub fn get_item_output_default() -> GetItemOutput {
  GetItemOutput(consumed_capacity: option.None, item: option.None)
}

pub fn encode_get_item_output_struct(input: GetItemOutput) -> json.Json {
  let pairs = []
  let pairs = case input.consumed_capacity {
    option.Some(v) -> [
      #("ConsumedCapacity", encode_consumed_capacity_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.item {
    option.Some(v) -> [
      #(
        "Item",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_get_item_output_struct_top(input: GetItemOutput) -> json.Json {
  let pairs = []
  let pairs = case input.consumed_capacity {
    option.Some(v) -> [
      #("ConsumedCapacity", encode_consumed_capacity_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.item {
    option.Some(v) -> [
      #(
        "Item",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_item_output_struct() -> decode.Decoder(GetItemOutput) {
  use <- decode.recursive
  use consumed_capacity <- decode.optional_field(
    "ConsumedCapacity",
    option.None,
    decode.optional(decode_consumed_capacity_struct()),
  )
  use item <- decode.optional_field(
    "Item",
    option.None,
    decode.optional(decode.dict(decode.string, decode_attribute_value_union())),
  )
  decode.success(GetItemOutput(consumed_capacity: consumed_capacity, item: item))
}

pub type GetResourcePolicyInput {
  GetResourcePolicyInput(resource_arn: option.Option(String))
}

pub fn get_resource_policy_input_default() -> GetResourcePolicyInput {
  GetResourcePolicyInput(resource_arn: option.None)
}

pub fn encode_get_resource_policy_input_struct(
  input: GetResourcePolicyInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.resource_arn {
    option.Some(v) -> [#("ResourceArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_get_resource_policy_input_struct_top(
  input: GetResourcePolicyInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.resource_arn {
    option.Some(v) -> [#("ResourceArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_resource_policy_input_struct() -> decode.Decoder(
  GetResourcePolicyInput,
) {
  use <- decode.recursive
  use resource_arn <- decode.optional_field(
    "ResourceArn",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetResourcePolicyInput(resource_arn: resource_arn))
}

pub type GetResourcePolicyOutput {
  GetResourcePolicyOutput(
    policy: option.Option(String),
    revision_id: option.Option(String),
  )
}

pub fn get_resource_policy_output_default() -> GetResourcePolicyOutput {
  GetResourcePolicyOutput(policy: option.None, revision_id: option.None)
}

pub fn encode_get_resource_policy_output_struct(
  input: GetResourcePolicyOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.policy {
    option.Some(v) -> [#("Policy", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.revision_id {
    option.Some(v) -> [#("RevisionId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_get_resource_policy_output_struct_top(
  input: GetResourcePolicyOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.policy {
    option.Some(v) -> [#("Policy", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.revision_id {
    option.Some(v) -> [#("RevisionId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_resource_policy_output_struct() -> decode.Decoder(
  GetResourcePolicyOutput,
) {
  use <- decode.recursive
  use policy <- decode.optional_field(
    "Policy",
    option.None,
    decode.optional(decode.string),
  )
  use revision_id <- decode.optional_field(
    "RevisionId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetResourcePolicyOutput(
    policy: policy,
    revision_id: revision_id,
  ))
}

pub type ImportTableInput {
  ImportTableInput(
    client_token: option.Option(String),
    input_compression_type: option.Option(InputCompressionType),
    input_format: option.Option(InputFormat),
    input_format_options: option.Option(InputFormatOptions),
    s3_bucket_source: option.Option(S3BucketSource),
    table_creation_parameters: option.Option(TableCreationParameters),
  )
}

pub fn import_table_input_default() -> ImportTableInput {
  ImportTableInput(
    client_token: option.None,
    input_compression_type: option.None,
    input_format: option.None,
    input_format_options: option.None,
    s3_bucket_source: option.None,
    table_creation_parameters: option.None,
  )
}

pub fn encode_import_table_input_struct(input: ImportTableInput) -> json.Json {
  let pairs = []
  let pairs = case input.client_token {
    option.Some(v) -> [#("ClientToken", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.input_compression_type {
    option.Some(v) -> [
      #("InputCompressionType", encode_input_compression_type_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.input_format {
    option.Some(v) -> [#("InputFormat", encode_input_format_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.input_format_options {
    option.Some(v) -> [
      #("InputFormatOptions", encode_input_format_options_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.s3_bucket_source {
    option.Some(v) -> [
      #("S3BucketSource", encode_s3_bucket_source_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_creation_parameters {
    option.Some(v) -> [
      #("TableCreationParameters", encode_table_creation_parameters_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_import_table_input_struct_top(
  input: ImportTableInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.client_token {
    option.Some(v) -> [#("ClientToken", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.input_compression_type {
    option.Some(v) -> [
      #("InputCompressionType", encode_input_compression_type_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.input_format {
    option.Some(v) -> [#("InputFormat", encode_input_format_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.input_format_options {
    option.Some(v) -> [
      #("InputFormatOptions", encode_input_format_options_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.s3_bucket_source {
    option.Some(v) -> [
      #("S3BucketSource", encode_s3_bucket_source_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_creation_parameters {
    option.Some(v) -> [
      #("TableCreationParameters", encode_table_creation_parameters_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_import_table_input_struct() -> decode.Decoder(ImportTableInput) {
  use <- decode.recursive
  use client_token <- decode.optional_field(
    "ClientToken",
    option.None,
    decode.optional(decode.string),
  )
  use input_compression_type <- decode.optional_field(
    "InputCompressionType",
    option.None,
    decode.optional(decode_input_compression_type_enum()),
  )
  use input_format <- decode.optional_field(
    "InputFormat",
    option.None,
    decode.optional(decode_input_format_enum()),
  )
  use input_format_options <- decode.optional_field(
    "InputFormatOptions",
    option.None,
    decode.optional(decode_input_format_options_struct()),
  )
  use s3_bucket_source <- decode.optional_field(
    "S3BucketSource",
    option.None,
    decode.optional(decode_s3_bucket_source_struct()),
  )
  use table_creation_parameters <- decode.optional_field(
    "TableCreationParameters",
    option.None,
    decode.optional(decode_table_creation_parameters_struct()),
  )
  decode.success(ImportTableInput(
    client_token: client_token,
    input_compression_type: input_compression_type,
    input_format: input_format,
    input_format_options: input_format_options,
    s3_bucket_source: s3_bucket_source,
    table_creation_parameters: table_creation_parameters,
  ))
}

pub type ImportTableOutput {
  ImportTableOutput(
    import_table_description: option.Option(ImportTableDescription),
  )
}

pub fn import_table_output_default() -> ImportTableOutput {
  ImportTableOutput(import_table_description: option.None)
}

pub fn encode_import_table_output_struct(
  input: ImportTableOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.import_table_description {
    option.Some(v) -> [
      #("ImportTableDescription", encode_import_table_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_import_table_output_struct_top(
  input: ImportTableOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.import_table_description {
    option.Some(v) -> [
      #("ImportTableDescription", encode_import_table_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_import_table_output_struct() -> decode.Decoder(ImportTableOutput) {
  use <- decode.recursive
  use import_table_description <- decode.optional_field(
    "ImportTableDescription",
    option.None,
    decode.optional(decode_import_table_description_struct()),
  )
  decode.success(ImportTableOutput(
    import_table_description: import_table_description,
  ))
}

pub type ImportConflictException {
  ImportConflictException(message: option.Option(String))
}

pub fn import_conflict_exception_default() -> ImportConflictException {
  ImportConflictException(message: option.None)
}

pub fn encode_import_conflict_exception_struct(
  input: ImportConflictException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_import_conflict_exception_struct_top(
  input: ImportConflictException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_import_conflict_exception_struct() -> decode.Decoder(
  ImportConflictException,
) {
  use <- decode.recursive
  use message <- decode.optional_field(
    "message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ImportConflictException(message: message))
}

pub type ListBackupsInput {
  ListBackupsInput(
    backup_type: option.Option(BackupTypeFilter),
    exclusive_start_backup_arn: option.Option(String),
    limit: option.Option(Int),
    table_name: option.Option(String),
    time_range_lower_bound: option.Option(json_timestamp.Timestamp),
    time_range_upper_bound: option.Option(json_timestamp.Timestamp),
  )
}

pub fn list_backups_input_default() -> ListBackupsInput {
  ListBackupsInput(
    backup_type: option.None,
    exclusive_start_backup_arn: option.None,
    limit: option.None,
    table_name: option.None,
    time_range_lower_bound: option.None,
    time_range_upper_bound: option.None,
  )
}

pub fn encode_list_backups_input_struct(input: ListBackupsInput) -> json.Json {
  let pairs = []
  let pairs = case input.backup_type {
    option.Some(v) -> [
      #("BackupType", encode_backup_type_filter_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.exclusive_start_backup_arn {
    option.Some(v) -> [#("ExclusiveStartBackupArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.limit {
    option.Some(v) -> [#("Limit", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.time_range_lower_bound {
    option.Some(v) -> [
      #("TimeRangeLowerBound", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.time_range_upper_bound {
    option.Some(v) -> [
      #("TimeRangeUpperBound", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_list_backups_input_struct_top(
  input: ListBackupsInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.backup_type {
    option.Some(v) -> [
      #("BackupType", encode_backup_type_filter_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.exclusive_start_backup_arn {
    option.Some(v) -> [#("ExclusiveStartBackupArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.limit {
    option.Some(v) -> [#("Limit", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.time_range_lower_bound {
    option.Some(v) -> [
      #("TimeRangeLowerBound", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.time_range_upper_bound {
    option.Some(v) -> [
      #("TimeRangeUpperBound", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_list_backups_input_struct() -> decode.Decoder(ListBackupsInput) {
  use <- decode.recursive
  use backup_type <- decode.optional_field(
    "BackupType",
    option.None,
    decode.optional(decode_backup_type_filter_enum()),
  )
  use exclusive_start_backup_arn <- decode.optional_field(
    "ExclusiveStartBackupArn",
    option.None,
    decode.optional(decode.string),
  )
  use limit <- decode.optional_field(
    "Limit",
    option.None,
    decode.optional(decode.int),
  )
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  use time_range_lower_bound <- decode.optional_field(
    "TimeRangeLowerBound",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use time_range_upper_bound <- decode.optional_field(
    "TimeRangeUpperBound",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  decode.success(ListBackupsInput(
    backup_type: backup_type,
    exclusive_start_backup_arn: exclusive_start_backup_arn,
    limit: limit,
    table_name: table_name,
    time_range_lower_bound: time_range_lower_bound,
    time_range_upper_bound: time_range_upper_bound,
  ))
}

pub type BackupTypeFilter {
  BackupTypeFilterAll
  BackupTypeFilterAwsBackup
  BackupTypeFilterSystem
  BackupTypeFilterUser
}

pub fn encode_backup_type_filter_enum(v: BackupTypeFilter) -> json.Json {
  case v {
    BackupTypeFilterAll -> json.string("ALL")
    BackupTypeFilterAwsBackup -> json.string("AWS_BACKUP")
    BackupTypeFilterSystem -> json.string("SYSTEM")
    BackupTypeFilterUser -> json.string("USER")
  }
}

pub fn decode_backup_type_filter_enum() -> decode.Decoder(BackupTypeFilter) {
  decode.then(decode.string, fn(s) {
    case s {
      "ALL" -> decode.success(BackupTypeFilterAll)
      "AWS_BACKUP" -> decode.success(BackupTypeFilterAwsBackup)
      "SYSTEM" -> decode.success(BackupTypeFilterSystem)
      "USER" -> decode.success(BackupTypeFilterUser)
      _ -> decode.failure(BackupTypeFilterAll, "unknown enum value")
    }
  })
}

pub type ListBackupsOutput {
  ListBackupsOutput(
    backup_summaries: option.Option(List(BackupSummary)),
    last_evaluated_backup_arn: option.Option(String),
  )
}

pub fn list_backups_output_default() -> ListBackupsOutput {
  ListBackupsOutput(
    backup_summaries: option.None,
    last_evaluated_backup_arn: option.None,
  )
}

pub fn encode_list_backups_output_struct(
  input: ListBackupsOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.backup_summaries {
    option.Some(v) -> [
      #(
        "BackupSummaries",
        fn(xs) { json.array(xs, encode_backup_summary_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.last_evaluated_backup_arn {
    option.Some(v) -> [#("LastEvaluatedBackupArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_list_backups_output_struct_top(
  input: ListBackupsOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.backup_summaries {
    option.Some(v) -> [
      #(
        "BackupSummaries",
        fn(xs) { json.array(xs, encode_backup_summary_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.last_evaluated_backup_arn {
    option.Some(v) -> [#("LastEvaluatedBackupArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_list_backups_output_struct() -> decode.Decoder(ListBackupsOutput) {
  use <- decode.recursive
  use backup_summaries <- decode.optional_field(
    "BackupSummaries",
    option.None,
    decode.optional(decode.list(decode_backup_summary_struct())),
  )
  use last_evaluated_backup_arn <- decode.optional_field(
    "LastEvaluatedBackupArn",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ListBackupsOutput(
    backup_summaries: backup_summaries,
    last_evaluated_backup_arn: last_evaluated_backup_arn,
  ))
}

pub type BackupSummary {
  BackupSummary(
    backup_arn: option.Option(String),
    backup_creation_date_time: option.Option(json_timestamp.Timestamp),
    backup_expiry_date_time: option.Option(json_timestamp.Timestamp),
    backup_name: option.Option(String),
    backup_size_bytes: option.Option(Int),
    backup_status: option.Option(BackupStatus),
    backup_type: option.Option(BackupType),
    table_arn: option.Option(String),
    table_id: option.Option(String),
    table_name: option.Option(String),
  )
}

pub fn backup_summary_default() -> BackupSummary {
  BackupSummary(
    backup_arn: option.None,
    backup_creation_date_time: option.None,
    backup_expiry_date_time: option.None,
    backup_name: option.None,
    backup_size_bytes: option.None,
    backup_status: option.None,
    backup_type: option.None,
    table_arn: option.None,
    table_id: option.None,
    table_name: option.None,
  )
}

pub fn encode_backup_summary_struct(input: BackupSummary) -> json.Json {
  let pairs = []
  let pairs = case input.backup_arn {
    option.Some(v) -> [#("BackupArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.backup_creation_date_time {
    option.Some(v) -> [
      #("BackupCreationDateTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.backup_expiry_date_time {
    option.Some(v) -> [
      #("BackupExpiryDateTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.backup_name {
    option.Some(v) -> [#("BackupName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.backup_size_bytes {
    option.Some(v) -> [#("BackupSizeBytes", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.backup_status {
    option.Some(v) -> [#("BackupStatus", encode_backup_status_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.backup_type {
    option.Some(v) -> [#("BackupType", encode_backup_type_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_arn {
    option.Some(v) -> [#("TableArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_id {
    option.Some(v) -> [#("TableId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_backup_summary_struct_top(input: BackupSummary) -> json.Json {
  let pairs = []
  let pairs = case input.backup_arn {
    option.Some(v) -> [#("BackupArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.backup_creation_date_time {
    option.Some(v) -> [
      #("BackupCreationDateTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.backup_expiry_date_time {
    option.Some(v) -> [
      #("BackupExpiryDateTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.backup_name {
    option.Some(v) -> [#("BackupName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.backup_size_bytes {
    option.Some(v) -> [#("BackupSizeBytes", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.backup_status {
    option.Some(v) -> [#("BackupStatus", encode_backup_status_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.backup_type {
    option.Some(v) -> [#("BackupType", encode_backup_type_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_arn {
    option.Some(v) -> [#("TableArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_id {
    option.Some(v) -> [#("TableId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_backup_summary_struct() -> decode.Decoder(BackupSummary) {
  use <- decode.recursive
  use backup_arn <- decode.optional_field(
    "BackupArn",
    option.None,
    decode.optional(decode.string),
  )
  use backup_creation_date_time <- decode.optional_field(
    "BackupCreationDateTime",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use backup_expiry_date_time <- decode.optional_field(
    "BackupExpiryDateTime",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use backup_name <- decode.optional_field(
    "BackupName",
    option.None,
    decode.optional(decode.string),
  )
  use backup_size_bytes <- decode.optional_field(
    "BackupSizeBytes",
    option.None,
    decode.optional(decode.int),
  )
  use backup_status <- decode.optional_field(
    "BackupStatus",
    option.None,
    decode.optional(decode_backup_status_enum()),
  )
  use backup_type <- decode.optional_field(
    "BackupType",
    option.None,
    decode.optional(decode_backup_type_enum()),
  )
  use table_arn <- decode.optional_field(
    "TableArn",
    option.None,
    decode.optional(decode.string),
  )
  use table_id <- decode.optional_field(
    "TableId",
    option.None,
    decode.optional(decode.string),
  )
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(BackupSummary(
    backup_arn: backup_arn,
    backup_creation_date_time: backup_creation_date_time,
    backup_expiry_date_time: backup_expiry_date_time,
    backup_name: backup_name,
    backup_size_bytes: backup_size_bytes,
    backup_status: backup_status,
    backup_type: backup_type,
    table_arn: table_arn,
    table_id: table_id,
    table_name: table_name,
  ))
}

pub type ListContributorInsightsInput {
  ListContributorInsightsInput(
    max_results: option.Option(Int),
    next_token: option.Option(String),
    table_name: option.Option(String),
  )
}

pub fn list_contributor_insights_input_default() -> ListContributorInsightsInput {
  ListContributorInsightsInput(
    max_results: option.None,
    next_token: option.None,
    table_name: option.None,
  )
}

pub fn encode_list_contributor_insights_input_struct(
  input: ListContributorInsightsInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.max_results {
    option.Some(v) -> [#("MaxResults", json.int(v)), ..pairs]
    option.None -> [#("MaxResults", json.int(0)), ..pairs]
  }
  let pairs = case input.next_token {
    option.Some(v) -> [#("NextToken", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_list_contributor_insights_input_struct_top(
  input: ListContributorInsightsInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.max_results {
    option.Some(v) -> [#("MaxResults", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.next_token {
    option.Some(v) -> [#("NextToken", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_list_contributor_insights_input_struct() -> decode.Decoder(
  ListContributorInsightsInput,
) {
  use <- decode.recursive
  use max_results <- decode.optional_field(
    "MaxResults",
    option.None,
    decode.optional(decode.int),
  )
  use next_token <- decode.optional_field(
    "NextToken",
    option.None,
    decode.optional(decode.string),
  )
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ListContributorInsightsInput(
    max_results: max_results,
    next_token: next_token,
    table_name: table_name,
  ))
}

pub type ListContributorInsightsOutput {
  ListContributorInsightsOutput(
    contributor_insights_summaries: option.Option(
      List(ContributorInsightsSummary),
    ),
    next_token: option.Option(String),
  )
}

pub fn list_contributor_insights_output_default() -> ListContributorInsightsOutput {
  ListContributorInsightsOutput(
    contributor_insights_summaries: option.None,
    next_token: option.None,
  )
}

pub fn encode_list_contributor_insights_output_struct(
  input: ListContributorInsightsOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.contributor_insights_summaries {
    option.Some(v) -> [
      #(
        "ContributorInsightsSummaries",
        fn(xs) { json.array(xs, encode_contributor_insights_summary_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.next_token {
    option.Some(v) -> [#("NextToken", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_list_contributor_insights_output_struct_top(
  input: ListContributorInsightsOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.contributor_insights_summaries {
    option.Some(v) -> [
      #(
        "ContributorInsightsSummaries",
        fn(xs) { json.array(xs, encode_contributor_insights_summary_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.next_token {
    option.Some(v) -> [#("NextToken", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_list_contributor_insights_output_struct() -> decode.Decoder(
  ListContributorInsightsOutput,
) {
  use <- decode.recursive
  use contributor_insights_summaries <- decode.optional_field(
    "ContributorInsightsSummaries",
    option.None,
    decode.optional(decode.list(decode_contributor_insights_summary_struct())),
  )
  use next_token <- decode.optional_field(
    "NextToken",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ListContributorInsightsOutput(
    contributor_insights_summaries: contributor_insights_summaries,
    next_token: next_token,
  ))
}

pub type ContributorInsightsSummary {
  ContributorInsightsSummary(
    contributor_insights_mode: option.Option(ContributorInsightsMode),
    contributor_insights_status: option.Option(ContributorInsightsStatus),
    index_name: option.Option(String),
    table_name: option.Option(String),
  )
}

pub fn contributor_insights_summary_default() -> ContributorInsightsSummary {
  ContributorInsightsSummary(
    contributor_insights_mode: option.None,
    contributor_insights_status: option.None,
    index_name: option.None,
    table_name: option.None,
  )
}

pub fn encode_contributor_insights_summary_struct(
  input: ContributorInsightsSummary,
) -> json.Json {
  let pairs = []
  let pairs = case input.contributor_insights_mode {
    option.Some(v) -> [
      #("ContributorInsightsMode", encode_contributor_insights_mode_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.contributor_insights_status {
    option.Some(v) -> [
      #("ContributorInsightsStatus", encode_contributor_insights_status_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_contributor_insights_summary_struct_top(
  input: ContributorInsightsSummary,
) -> json.Json {
  let pairs = []
  let pairs = case input.contributor_insights_mode {
    option.Some(v) -> [
      #("ContributorInsightsMode", encode_contributor_insights_mode_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.contributor_insights_status {
    option.Some(v) -> [
      #("ContributorInsightsStatus", encode_contributor_insights_status_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_contributor_insights_summary_struct() -> decode.Decoder(
  ContributorInsightsSummary,
) {
  use <- decode.recursive
  use contributor_insights_mode <- decode.optional_field(
    "ContributorInsightsMode",
    option.None,
    decode.optional(decode_contributor_insights_mode_enum()),
  )
  use contributor_insights_status <- decode.optional_field(
    "ContributorInsightsStatus",
    option.None,
    decode.optional(decode_contributor_insights_status_enum()),
  )
  use index_name <- decode.optional_field(
    "IndexName",
    option.None,
    decode.optional(decode.string),
  )
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ContributorInsightsSummary(
    contributor_insights_mode: contributor_insights_mode,
    contributor_insights_status: contributor_insights_status,
    index_name: index_name,
    table_name: table_name,
  ))
}

pub type ListExportsInput {
  ListExportsInput(
    max_results: option.Option(Int),
    next_token: option.Option(String),
    table_arn: option.Option(String),
  )
}

pub fn list_exports_input_default() -> ListExportsInput {
  ListExportsInput(
    max_results: option.None,
    next_token: option.None,
    table_arn: option.None,
  )
}

pub fn encode_list_exports_input_struct(input: ListExportsInput) -> json.Json {
  let pairs = []
  let pairs = case input.max_results {
    option.Some(v) -> [#("MaxResults", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.next_token {
    option.Some(v) -> [#("NextToken", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_arn {
    option.Some(v) -> [#("TableArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_list_exports_input_struct_top(
  input: ListExportsInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.max_results {
    option.Some(v) -> [#("MaxResults", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.next_token {
    option.Some(v) -> [#("NextToken", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_arn {
    option.Some(v) -> [#("TableArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_list_exports_input_struct() -> decode.Decoder(ListExportsInput) {
  use <- decode.recursive
  use max_results <- decode.optional_field(
    "MaxResults",
    option.None,
    decode.optional(decode.int),
  )
  use next_token <- decode.optional_field(
    "NextToken",
    option.None,
    decode.optional(decode.string),
  )
  use table_arn <- decode.optional_field(
    "TableArn",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ListExportsInput(
    max_results: max_results,
    next_token: next_token,
    table_arn: table_arn,
  ))
}

pub type ListExportsOutput {
  ListExportsOutput(
    export_summaries: option.Option(List(ExportSummary)),
    next_token: option.Option(String),
  )
}

pub fn list_exports_output_default() -> ListExportsOutput {
  ListExportsOutput(export_summaries: option.None, next_token: option.None)
}

pub fn encode_list_exports_output_struct(
  input: ListExportsOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.export_summaries {
    option.Some(v) -> [
      #(
        "ExportSummaries",
        fn(xs) { json.array(xs, encode_export_summary_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.next_token {
    option.Some(v) -> [#("NextToken", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_list_exports_output_struct_top(
  input: ListExportsOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.export_summaries {
    option.Some(v) -> [
      #(
        "ExportSummaries",
        fn(xs) { json.array(xs, encode_export_summary_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.next_token {
    option.Some(v) -> [#("NextToken", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_list_exports_output_struct() -> decode.Decoder(ListExportsOutput) {
  use <- decode.recursive
  use export_summaries <- decode.optional_field(
    "ExportSummaries",
    option.None,
    decode.optional(decode.list(decode_export_summary_struct())),
  )
  use next_token <- decode.optional_field(
    "NextToken",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ListExportsOutput(
    export_summaries: export_summaries,
    next_token: next_token,
  ))
}

pub type ExportSummary {
  ExportSummary(
    export_arn: option.Option(String),
    export_status: option.Option(ExportStatus),
    export_type: option.Option(ExportType),
  )
}

pub fn export_summary_default() -> ExportSummary {
  ExportSummary(
    export_arn: option.None,
    export_status: option.None,
    export_type: option.None,
  )
}

pub fn encode_export_summary_struct(input: ExportSummary) -> json.Json {
  let pairs = []
  let pairs = case input.export_arn {
    option.Some(v) -> [#("ExportArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.export_status {
    option.Some(v) -> [#("ExportStatus", encode_export_status_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.export_type {
    option.Some(v) -> [#("ExportType", encode_export_type_enum(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_export_summary_struct_top(input: ExportSummary) -> json.Json {
  let pairs = []
  let pairs = case input.export_arn {
    option.Some(v) -> [#("ExportArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.export_status {
    option.Some(v) -> [#("ExportStatus", encode_export_status_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.export_type {
    option.Some(v) -> [#("ExportType", encode_export_type_enum(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_export_summary_struct() -> decode.Decoder(ExportSummary) {
  use <- decode.recursive
  use export_arn <- decode.optional_field(
    "ExportArn",
    option.None,
    decode.optional(decode.string),
  )
  use export_status <- decode.optional_field(
    "ExportStatus",
    option.None,
    decode.optional(decode_export_status_enum()),
  )
  use export_type <- decode.optional_field(
    "ExportType",
    option.None,
    decode.optional(decode_export_type_enum()),
  )
  decode.success(ExportSummary(
    export_arn: export_arn,
    export_status: export_status,
    export_type: export_type,
  ))
}

pub type ListGlobalTablesInput {
  ListGlobalTablesInput(
    exclusive_start_global_table_name: option.Option(String),
    limit: option.Option(Int),
    region_name: option.Option(String),
  )
}

pub fn list_global_tables_input_default() -> ListGlobalTablesInput {
  ListGlobalTablesInput(
    exclusive_start_global_table_name: option.None,
    limit: option.None,
    region_name: option.None,
  )
}

pub fn encode_list_global_tables_input_struct(
  input: ListGlobalTablesInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.exclusive_start_global_table_name {
    option.Some(v) -> [
      #("ExclusiveStartGlobalTableName", json.string(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.limit {
    option.Some(v) -> [#("Limit", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.region_name {
    option.Some(v) -> [#("RegionName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_list_global_tables_input_struct_top(
  input: ListGlobalTablesInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.exclusive_start_global_table_name {
    option.Some(v) -> [
      #("ExclusiveStartGlobalTableName", json.string(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.limit {
    option.Some(v) -> [#("Limit", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.region_name {
    option.Some(v) -> [#("RegionName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_list_global_tables_input_struct() -> decode.Decoder(
  ListGlobalTablesInput,
) {
  use <- decode.recursive
  use exclusive_start_global_table_name <- decode.optional_field(
    "ExclusiveStartGlobalTableName",
    option.None,
    decode.optional(decode.string),
  )
  use limit <- decode.optional_field(
    "Limit",
    option.None,
    decode.optional(decode.int),
  )
  use region_name <- decode.optional_field(
    "RegionName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ListGlobalTablesInput(
    exclusive_start_global_table_name: exclusive_start_global_table_name,
    limit: limit,
    region_name: region_name,
  ))
}

pub type ListGlobalTablesOutput {
  ListGlobalTablesOutput(
    global_tables: option.Option(List(GlobalTable)),
    last_evaluated_global_table_name: option.Option(String),
  )
}

pub fn list_global_tables_output_default() -> ListGlobalTablesOutput {
  ListGlobalTablesOutput(
    global_tables: option.None,
    last_evaluated_global_table_name: option.None,
  )
}

pub fn encode_list_global_tables_output_struct(
  input: ListGlobalTablesOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.global_tables {
    option.Some(v) -> [
      #(
        "GlobalTables",
        fn(xs) { json.array(xs, encode_global_table_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.last_evaluated_global_table_name {
    option.Some(v) -> [
      #("LastEvaluatedGlobalTableName", json.string(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_list_global_tables_output_struct_top(
  input: ListGlobalTablesOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.global_tables {
    option.Some(v) -> [
      #(
        "GlobalTables",
        fn(xs) { json.array(xs, encode_global_table_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.last_evaluated_global_table_name {
    option.Some(v) -> [
      #("LastEvaluatedGlobalTableName", json.string(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_list_global_tables_output_struct() -> decode.Decoder(
  ListGlobalTablesOutput,
) {
  use <- decode.recursive
  use global_tables <- decode.optional_field(
    "GlobalTables",
    option.None,
    decode.optional(decode.list(decode_global_table_struct())),
  )
  use last_evaluated_global_table_name <- decode.optional_field(
    "LastEvaluatedGlobalTableName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ListGlobalTablesOutput(
    global_tables: global_tables,
    last_evaluated_global_table_name: last_evaluated_global_table_name,
  ))
}

pub type GlobalTable {
  GlobalTable(
    global_table_name: option.Option(String),
    replication_group: option.Option(List(Replica)),
  )
}

pub fn global_table_default() -> GlobalTable {
  GlobalTable(global_table_name: option.None, replication_group: option.None)
}

pub fn encode_global_table_struct(input: GlobalTable) -> json.Json {
  let pairs = []
  let pairs = case input.global_table_name {
    option.Some(v) -> [#("GlobalTableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.replication_group {
    option.Some(v) -> [
      #("ReplicationGroup", fn(xs) { json.array(xs, encode_replica_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_global_table_struct_top(input: GlobalTable) -> json.Json {
  let pairs = []
  let pairs = case input.global_table_name {
    option.Some(v) -> [#("GlobalTableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.replication_group {
    option.Some(v) -> [
      #("ReplicationGroup", fn(xs) { json.array(xs, encode_replica_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_global_table_struct() -> decode.Decoder(GlobalTable) {
  use <- decode.recursive
  use global_table_name <- decode.optional_field(
    "GlobalTableName",
    option.None,
    decode.optional(decode.string),
  )
  use replication_group <- decode.optional_field(
    "ReplicationGroup",
    option.None,
    decode.optional(decode.list(decode_replica_struct())),
  )
  decode.success(GlobalTable(
    global_table_name: global_table_name,
    replication_group: replication_group,
  ))
}

pub type ListImportsInput {
  ListImportsInput(
    next_token: option.Option(String),
    page_size: option.Option(Int),
    table_arn: option.Option(String),
  )
}

pub fn list_imports_input_default() -> ListImportsInput {
  ListImportsInput(
    next_token: option.None,
    page_size: option.None,
    table_arn: option.None,
  )
}

pub fn encode_list_imports_input_struct(input: ListImportsInput) -> json.Json {
  let pairs = []
  let pairs = case input.next_token {
    option.Some(v) -> [#("NextToken", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.page_size {
    option.Some(v) -> [#("PageSize", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_arn {
    option.Some(v) -> [#("TableArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_list_imports_input_struct_top(
  input: ListImportsInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.next_token {
    option.Some(v) -> [#("NextToken", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.page_size {
    option.Some(v) -> [#("PageSize", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_arn {
    option.Some(v) -> [#("TableArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_list_imports_input_struct() -> decode.Decoder(ListImportsInput) {
  use <- decode.recursive
  use next_token <- decode.optional_field(
    "NextToken",
    option.None,
    decode.optional(decode.string),
  )
  use page_size <- decode.optional_field(
    "PageSize",
    option.None,
    decode.optional(decode.int),
  )
  use table_arn <- decode.optional_field(
    "TableArn",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ListImportsInput(
    next_token: next_token,
    page_size: page_size,
    table_arn: table_arn,
  ))
}

pub type ListImportsOutput {
  ListImportsOutput(
    import_summary_list: option.Option(List(ImportSummary)),
    next_token: option.Option(String),
  )
}

pub fn list_imports_output_default() -> ListImportsOutput {
  ListImportsOutput(import_summary_list: option.None, next_token: option.None)
}

pub fn encode_list_imports_output_struct(
  input: ListImportsOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.import_summary_list {
    option.Some(v) -> [
      #(
        "ImportSummaryList",
        fn(xs) { json.array(xs, encode_import_summary_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.next_token {
    option.Some(v) -> [#("NextToken", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_list_imports_output_struct_top(
  input: ListImportsOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.import_summary_list {
    option.Some(v) -> [
      #(
        "ImportSummaryList",
        fn(xs) { json.array(xs, encode_import_summary_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.next_token {
    option.Some(v) -> [#("NextToken", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_list_imports_output_struct() -> decode.Decoder(ListImportsOutput) {
  use <- decode.recursive
  use import_summary_list <- decode.optional_field(
    "ImportSummaryList",
    option.None,
    decode.optional(decode.list(decode_import_summary_struct())),
  )
  use next_token <- decode.optional_field(
    "NextToken",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ListImportsOutput(
    import_summary_list: import_summary_list,
    next_token: next_token,
  ))
}

pub type ImportSummary {
  ImportSummary(
    cloud_watch_log_group_arn: option.Option(String),
    end_time: option.Option(json_timestamp.Timestamp),
    import_arn: option.Option(String),
    import_status: option.Option(ImportStatus),
    input_format: option.Option(InputFormat),
    s3_bucket_source: option.Option(S3BucketSource),
    start_time: option.Option(json_timestamp.Timestamp),
    table_arn: option.Option(String),
  )
}

pub fn import_summary_default() -> ImportSummary {
  ImportSummary(
    cloud_watch_log_group_arn: option.None,
    end_time: option.None,
    import_arn: option.None,
    import_status: option.None,
    input_format: option.None,
    s3_bucket_source: option.None,
    start_time: option.None,
    table_arn: option.None,
  )
}

pub fn encode_import_summary_struct(input: ImportSummary) -> json.Json {
  let pairs = []
  let pairs = case input.cloud_watch_log_group_arn {
    option.Some(v) -> [#("CloudWatchLogGroupArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.end_time {
    option.Some(v) -> [
      #("EndTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.import_arn {
    option.Some(v) -> [#("ImportArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.import_status {
    option.Some(v) -> [#("ImportStatus", encode_import_status_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.input_format {
    option.Some(v) -> [#("InputFormat", encode_input_format_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.s3_bucket_source {
    option.Some(v) -> [
      #("S3BucketSource", encode_s3_bucket_source_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.start_time {
    option.Some(v) -> [
      #("StartTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_arn {
    option.Some(v) -> [#("TableArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_import_summary_struct_top(input: ImportSummary) -> json.Json {
  let pairs = []
  let pairs = case input.cloud_watch_log_group_arn {
    option.Some(v) -> [#("CloudWatchLogGroupArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.end_time {
    option.Some(v) -> [
      #("EndTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.import_arn {
    option.Some(v) -> [#("ImportArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.import_status {
    option.Some(v) -> [#("ImportStatus", encode_import_status_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.input_format {
    option.Some(v) -> [#("InputFormat", encode_input_format_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.s3_bucket_source {
    option.Some(v) -> [
      #("S3BucketSource", encode_s3_bucket_source_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.start_time {
    option.Some(v) -> [
      #("StartTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_arn {
    option.Some(v) -> [#("TableArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_import_summary_struct() -> decode.Decoder(ImportSummary) {
  use <- decode.recursive
  use cloud_watch_log_group_arn <- decode.optional_field(
    "CloudWatchLogGroupArn",
    option.None,
    decode.optional(decode.string),
  )
  use end_time <- decode.optional_field(
    "EndTime",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use import_arn <- decode.optional_field(
    "ImportArn",
    option.None,
    decode.optional(decode.string),
  )
  use import_status <- decode.optional_field(
    "ImportStatus",
    option.None,
    decode.optional(decode_import_status_enum()),
  )
  use input_format <- decode.optional_field(
    "InputFormat",
    option.None,
    decode.optional(decode_input_format_enum()),
  )
  use s3_bucket_source <- decode.optional_field(
    "S3BucketSource",
    option.None,
    decode.optional(decode_s3_bucket_source_struct()),
  )
  use start_time <- decode.optional_field(
    "StartTime",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use table_arn <- decode.optional_field(
    "TableArn",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ImportSummary(
    cloud_watch_log_group_arn: cloud_watch_log_group_arn,
    end_time: end_time,
    import_arn: import_arn,
    import_status: import_status,
    input_format: input_format,
    s3_bucket_source: s3_bucket_source,
    start_time: start_time,
    table_arn: table_arn,
  ))
}

pub type ListTablesInput {
  ListTablesInput(
    exclusive_start_table_name: option.Option(String),
    limit: option.Option(Int),
  )
}

pub fn list_tables_input_default() -> ListTablesInput {
  ListTablesInput(exclusive_start_table_name: option.None, limit: option.None)
}

pub fn encode_list_tables_input_struct(input: ListTablesInput) -> json.Json {
  let pairs = []
  let pairs = case input.exclusive_start_table_name {
    option.Some(v) -> [#("ExclusiveStartTableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.limit {
    option.Some(v) -> [#("Limit", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_list_tables_input_struct_top(
  input: ListTablesInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.exclusive_start_table_name {
    option.Some(v) -> [#("ExclusiveStartTableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.limit {
    option.Some(v) -> [#("Limit", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_list_tables_input_struct() -> decode.Decoder(ListTablesInput) {
  use <- decode.recursive
  use exclusive_start_table_name <- decode.optional_field(
    "ExclusiveStartTableName",
    option.None,
    decode.optional(decode.string),
  )
  use limit <- decode.optional_field(
    "Limit",
    option.None,
    decode.optional(decode.int),
  )
  decode.success(ListTablesInput(
    exclusive_start_table_name: exclusive_start_table_name,
    limit: limit,
  ))
}

pub type ListTablesOutput {
  ListTablesOutput(
    last_evaluated_table_name: option.Option(String),
    table_names: option.Option(List(String)),
  )
}

pub fn list_tables_output_default() -> ListTablesOutput {
  ListTablesOutput(
    last_evaluated_table_name: option.None,
    table_names: option.None,
  )
}

pub fn encode_list_tables_output_struct(input: ListTablesOutput) -> json.Json {
  let pairs = []
  let pairs = case input.last_evaluated_table_name {
    option.Some(v) -> [#("LastEvaluatedTableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_names {
    option.Some(v) -> [
      #("TableNames", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_list_tables_output_struct_top(
  input: ListTablesOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.last_evaluated_table_name {
    option.Some(v) -> [#("LastEvaluatedTableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_names {
    option.Some(v) -> [
      #("TableNames", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_list_tables_output_struct() -> decode.Decoder(ListTablesOutput) {
  use <- decode.recursive
  use last_evaluated_table_name <- decode.optional_field(
    "LastEvaluatedTableName",
    option.None,
    decode.optional(decode.string),
  )
  use table_names <- decode.optional_field(
    "TableNames",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  decode.success(ListTablesOutput(
    last_evaluated_table_name: last_evaluated_table_name,
    table_names: table_names,
  ))
}

pub type ListTagsOfResourceInput {
  ListTagsOfResourceInput(
    next_token: option.Option(String),
    resource_arn: option.Option(String),
  )
}

pub fn list_tags_of_resource_input_default() -> ListTagsOfResourceInput {
  ListTagsOfResourceInput(next_token: option.None, resource_arn: option.None)
}

pub fn encode_list_tags_of_resource_input_struct(
  input: ListTagsOfResourceInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.next_token {
    option.Some(v) -> [#("NextToken", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.resource_arn {
    option.Some(v) -> [#("ResourceArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_list_tags_of_resource_input_struct_top(
  input: ListTagsOfResourceInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.next_token {
    option.Some(v) -> [#("NextToken", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.resource_arn {
    option.Some(v) -> [#("ResourceArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_list_tags_of_resource_input_struct() -> decode.Decoder(
  ListTagsOfResourceInput,
) {
  use <- decode.recursive
  use next_token <- decode.optional_field(
    "NextToken",
    option.None,
    decode.optional(decode.string),
  )
  use resource_arn <- decode.optional_field(
    "ResourceArn",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ListTagsOfResourceInput(
    next_token: next_token,
    resource_arn: resource_arn,
  ))
}

pub type ListTagsOfResourceOutput {
  ListTagsOfResourceOutput(
    next_token: option.Option(String),
    tags: option.Option(List(Tag)),
  )
}

pub fn list_tags_of_resource_output_default() -> ListTagsOfResourceOutput {
  ListTagsOfResourceOutput(next_token: option.None, tags: option.None)
}

pub fn encode_list_tags_of_resource_output_struct(
  input: ListTagsOfResourceOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.next_token {
    option.Some(v) -> [#("NextToken", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.tags {
    option.Some(v) -> [
      #("Tags", fn(xs) { json.array(xs, encode_tag_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_list_tags_of_resource_output_struct_top(
  input: ListTagsOfResourceOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.next_token {
    option.Some(v) -> [#("NextToken", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.tags {
    option.Some(v) -> [
      #("Tags", fn(xs) { json.array(xs, encode_tag_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_list_tags_of_resource_output_struct() -> decode.Decoder(
  ListTagsOfResourceOutput,
) {
  use <- decode.recursive
  use next_token <- decode.optional_field(
    "NextToken",
    option.None,
    decode.optional(decode.string),
  )
  use tags <- decode.optional_field(
    "Tags",
    option.None,
    decode.optional(decode.list(decode_tag_struct())),
  )
  decode.success(ListTagsOfResourceOutput(next_token: next_token, tags: tags))
}

pub type PutItemInput {
  PutItemInput(
    condition_expression: option.Option(String),
    conditional_operator: option.Option(ConditionalOperator),
    expected: option.Option(dict.Dict(String, ExpectedAttributeValue)),
    expression_attribute_names: option.Option(dict.Dict(String, String)),
    expression_attribute_values: option.Option(
      dict.Dict(String, AttributeValue),
    ),
    item: option.Option(dict.Dict(String, AttributeValue)),
    return_consumed_capacity: option.Option(ReturnConsumedCapacity),
    return_item_collection_metrics: option.Option(ReturnItemCollectionMetrics),
    return_values: option.Option(ReturnValue),
    return_values_on_condition_check_failure: option.Option(
      ReturnValuesOnConditionCheckFailure,
    ),
    table_name: option.Option(String),
  )
}

pub fn put_item_input_default() -> PutItemInput {
  PutItemInput(
    condition_expression: option.None,
    conditional_operator: option.None,
    expected: option.None,
    expression_attribute_names: option.None,
    expression_attribute_values: option.None,
    item: option.None,
    return_consumed_capacity: option.None,
    return_item_collection_metrics: option.None,
    return_values: option.None,
    return_values_on_condition_check_failure: option.None,
    table_name: option.None,
  )
}

pub fn encode_put_item_input_struct(input: PutItemInput) -> json.Json {
  let pairs = []
  let pairs = case input.condition_expression {
    option.Some(v) -> [#("ConditionExpression", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.conditional_operator {
    option.Some(v) -> [
      #("ConditionalOperator", encode_conditional_operator_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.expected {
    option.Some(v) -> [
      #(
        "Expected",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_expected_attribute_value_struct(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_names {
    option.Some(v) -> [
      #(
        "ExpressionAttributeNames",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_values {
    option.Some(v) -> [
      #(
        "ExpressionAttributeValues",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.item {
    option.Some(v) -> [
      #(
        "Item",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_consumed_capacity {
    option.Some(v) -> [
      #("ReturnConsumedCapacity", encode_return_consumed_capacity_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_item_collection_metrics {
    option.Some(v) -> [
      #(
        "ReturnItemCollectionMetrics",
        encode_return_item_collection_metrics_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_values {
    option.Some(v) -> [#("ReturnValues", encode_return_value_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.return_values_on_condition_check_failure {
    option.Some(v) -> [
      #(
        "ReturnValuesOnConditionCheckFailure",
        encode_return_values_on_condition_check_failure_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_put_item_input_struct_top(input: PutItemInput) -> json.Json {
  let pairs = []
  let pairs = case input.condition_expression {
    option.Some(v) -> [#("ConditionExpression", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.conditional_operator {
    option.Some(v) -> [
      #("ConditionalOperator", encode_conditional_operator_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.expected {
    option.Some(v) -> [
      #(
        "Expected",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_expected_attribute_value_struct(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_names {
    option.Some(v) -> [
      #(
        "ExpressionAttributeNames",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_values {
    option.Some(v) -> [
      #(
        "ExpressionAttributeValues",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.item {
    option.Some(v) -> [
      #(
        "Item",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_consumed_capacity {
    option.Some(v) -> [
      #("ReturnConsumedCapacity", encode_return_consumed_capacity_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_item_collection_metrics {
    option.Some(v) -> [
      #(
        "ReturnItemCollectionMetrics",
        encode_return_item_collection_metrics_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_values {
    option.Some(v) -> [#("ReturnValues", encode_return_value_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.return_values_on_condition_check_failure {
    option.Some(v) -> [
      #(
        "ReturnValuesOnConditionCheckFailure",
        encode_return_values_on_condition_check_failure_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_put_item_input_struct() -> decode.Decoder(PutItemInput) {
  use <- decode.recursive
  use condition_expression <- decode.optional_field(
    "ConditionExpression",
    option.None,
    decode.optional(decode.string),
  )
  use conditional_operator <- decode.optional_field(
    "ConditionalOperator",
    option.None,
    decode.optional(decode_conditional_operator_enum()),
  )
  use expected <- decode.optional_field(
    "Expected",
    option.None,
    decode.optional(decode.dict(
      decode.string,
      decode_expected_attribute_value_struct(),
    )),
  )
  use expression_attribute_names <- decode.optional_field(
    "ExpressionAttributeNames",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use expression_attribute_values <- decode.optional_field(
    "ExpressionAttributeValues",
    option.None,
    decode.optional(decode.dict(decode.string, decode_attribute_value_union())),
  )
  use item <- decode.optional_field(
    "Item",
    option.None,
    decode.optional(decode.dict(decode.string, decode_attribute_value_union())),
  )
  use return_consumed_capacity <- decode.optional_field(
    "ReturnConsumedCapacity",
    option.None,
    decode.optional(decode_return_consumed_capacity_enum()),
  )
  use return_item_collection_metrics <- decode.optional_field(
    "ReturnItemCollectionMetrics",
    option.None,
    decode.optional(decode_return_item_collection_metrics_enum()),
  )
  use return_values <- decode.optional_field(
    "ReturnValues",
    option.None,
    decode.optional(decode_return_value_enum()),
  )
  use return_values_on_condition_check_failure <- decode.optional_field(
    "ReturnValuesOnConditionCheckFailure",
    option.None,
    decode.optional(decode_return_values_on_condition_check_failure_enum()),
  )
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(PutItemInput(
    condition_expression: condition_expression,
    conditional_operator: conditional_operator,
    expected: expected,
    expression_attribute_names: expression_attribute_names,
    expression_attribute_values: expression_attribute_values,
    item: item,
    return_consumed_capacity: return_consumed_capacity,
    return_item_collection_metrics: return_item_collection_metrics,
    return_values: return_values,
    return_values_on_condition_check_failure: return_values_on_condition_check_failure,
    table_name: table_name,
  ))
}

pub type PutItemOutput {
  PutItemOutput(
    attributes: option.Option(dict.Dict(String, AttributeValue)),
    consumed_capacity: option.Option(ConsumedCapacity),
    item_collection_metrics: option.Option(ItemCollectionMetrics),
  )
}

pub fn put_item_output_default() -> PutItemOutput {
  PutItemOutput(
    attributes: option.None,
    consumed_capacity: option.None,
    item_collection_metrics: option.None,
  )
}

pub fn encode_put_item_output_struct(input: PutItemOutput) -> json.Json {
  let pairs = []
  let pairs = case input.attributes {
    option.Some(v) -> [
      #(
        "Attributes",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.consumed_capacity {
    option.Some(v) -> [
      #("ConsumedCapacity", encode_consumed_capacity_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.item_collection_metrics {
    option.Some(v) -> [
      #("ItemCollectionMetrics", encode_item_collection_metrics_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_put_item_output_struct_top(input: PutItemOutput) -> json.Json {
  let pairs = []
  let pairs = case input.attributes {
    option.Some(v) -> [
      #(
        "Attributes",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.consumed_capacity {
    option.Some(v) -> [
      #("ConsumedCapacity", encode_consumed_capacity_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.item_collection_metrics {
    option.Some(v) -> [
      #("ItemCollectionMetrics", encode_item_collection_metrics_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_put_item_output_struct() -> decode.Decoder(PutItemOutput) {
  use <- decode.recursive
  use attributes <- decode.optional_field(
    "Attributes",
    option.None,
    decode.optional(decode.dict(decode.string, decode_attribute_value_union())),
  )
  use consumed_capacity <- decode.optional_field(
    "ConsumedCapacity",
    option.None,
    decode.optional(decode_consumed_capacity_struct()),
  )
  use item_collection_metrics <- decode.optional_field(
    "ItemCollectionMetrics",
    option.None,
    decode.optional(decode_item_collection_metrics_struct()),
  )
  decode.success(PutItemOutput(
    attributes: attributes,
    consumed_capacity: consumed_capacity,
    item_collection_metrics: item_collection_metrics,
  ))
}

pub type PutResourcePolicyInput {
  PutResourcePolicyInput(
    confirm_remove_self_resource_access: option.Option(Bool),
    expected_revision_id: option.Option(String),
    policy: option.Option(String),
    resource_arn: option.Option(String),
  )
}

pub fn put_resource_policy_input_default() -> PutResourcePolicyInput {
  PutResourcePolicyInput(
    confirm_remove_self_resource_access: option.None,
    expected_revision_id: option.None,
    policy: option.None,
    resource_arn: option.None,
  )
}

pub fn encode_put_resource_policy_input_struct(
  input: PutResourcePolicyInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.confirm_remove_self_resource_access {
    option.Some(v) -> [
      #("ConfirmRemoveSelfResourceAccess", json.bool(v)),
      ..pairs
    ]
    option.None -> [
      #("ConfirmRemoveSelfResourceAccess", json.bool(False)),
      ..pairs
    ]
  }
  let pairs = case input.expected_revision_id {
    option.Some(v) -> [#("ExpectedRevisionId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.policy {
    option.Some(v) -> [#("Policy", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.resource_arn {
    option.Some(v) -> [#("ResourceArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_put_resource_policy_input_struct_top(
  input: PutResourcePolicyInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.confirm_remove_self_resource_access {
    option.Some(v) -> [
      #("ConfirmRemoveSelfResourceAccess", json.bool(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.expected_revision_id {
    option.Some(v) -> [#("ExpectedRevisionId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.policy {
    option.Some(v) -> [#("Policy", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.resource_arn {
    option.Some(v) -> [#("ResourceArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_put_resource_policy_input_struct() -> decode.Decoder(
  PutResourcePolicyInput,
) {
  use <- decode.recursive
  use confirm_remove_self_resource_access <- decode.optional_field(
    "ConfirmRemoveSelfResourceAccess",
    option.None,
    decode.optional(decode.bool),
  )
  use expected_revision_id <- decode.optional_field(
    "ExpectedRevisionId",
    option.None,
    decode.optional(decode.string),
  )
  use policy <- decode.optional_field(
    "Policy",
    option.None,
    decode.optional(decode.string),
  )
  use resource_arn <- decode.optional_field(
    "ResourceArn",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(PutResourcePolicyInput(
    confirm_remove_self_resource_access: confirm_remove_self_resource_access,
    expected_revision_id: expected_revision_id,
    policy: policy,
    resource_arn: resource_arn,
  ))
}

pub type PutResourcePolicyOutput {
  PutResourcePolicyOutput(revision_id: option.Option(String))
}

pub fn put_resource_policy_output_default() -> PutResourcePolicyOutput {
  PutResourcePolicyOutput(revision_id: option.None)
}

pub fn encode_put_resource_policy_output_struct(
  input: PutResourcePolicyOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.revision_id {
    option.Some(v) -> [#("RevisionId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_put_resource_policy_output_struct_top(
  input: PutResourcePolicyOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.revision_id {
    option.Some(v) -> [#("RevisionId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_put_resource_policy_output_struct() -> decode.Decoder(
  PutResourcePolicyOutput,
) {
  use <- decode.recursive
  use revision_id <- decode.optional_field(
    "RevisionId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(PutResourcePolicyOutput(revision_id: revision_id))
}

pub type QueryInput {
  QueryInput(
    attributes_to_get: option.Option(List(String)),
    conditional_operator: option.Option(ConditionalOperator),
    consistent_read: option.Option(Bool),
    exclusive_start_key: option.Option(dict.Dict(String, AttributeValue)),
    expression_attribute_names: option.Option(dict.Dict(String, String)),
    expression_attribute_values: option.Option(
      dict.Dict(String, AttributeValue),
    ),
    filter_expression: option.Option(String),
    index_name: option.Option(String),
    key_condition_expression: option.Option(String),
    key_conditions: option.Option(dict.Dict(String, Condition)),
    limit: option.Option(Int),
    projection_expression: option.Option(String),
    query_filter: option.Option(dict.Dict(String, Condition)),
    return_consumed_capacity: option.Option(ReturnConsumedCapacity),
    scan_index_forward: option.Option(Bool),
    select: option.Option(Select),
    table_name: option.Option(String),
  )
}

pub fn query_input_default() -> QueryInput {
  QueryInput(
    attributes_to_get: option.None,
    conditional_operator: option.None,
    consistent_read: option.None,
    exclusive_start_key: option.None,
    expression_attribute_names: option.None,
    expression_attribute_values: option.None,
    filter_expression: option.None,
    index_name: option.None,
    key_condition_expression: option.None,
    key_conditions: option.None,
    limit: option.None,
    projection_expression: option.None,
    query_filter: option.None,
    return_consumed_capacity: option.None,
    scan_index_forward: option.None,
    select: option.None,
    table_name: option.None,
  )
}

pub fn encode_query_input_struct(input: QueryInput) -> json.Json {
  let pairs = []
  let pairs = case input.attributes_to_get {
    option.Some(v) -> [
      #("AttributesToGet", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.conditional_operator {
    option.Some(v) -> [
      #("ConditionalOperator", encode_conditional_operator_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.consistent_read {
    option.Some(v) -> [#("ConsistentRead", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.exclusive_start_key {
    option.Some(v) -> [
      #(
        "ExclusiveStartKey",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_names {
    option.Some(v) -> [
      #(
        "ExpressionAttributeNames",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_values {
    option.Some(v) -> [
      #(
        "ExpressionAttributeValues",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.filter_expression {
    option.Some(v) -> [#("FilterExpression", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.key_condition_expression {
    option.Some(v) -> [#("KeyConditionExpression", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.key_conditions {
    option.Some(v) -> [
      #(
        "KeyConditions",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, encode_condition_struct(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.limit {
    option.Some(v) -> [#("Limit", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.projection_expression {
    option.Some(v) -> [#("ProjectionExpression", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.query_filter {
    option.Some(v) -> [
      #(
        "QueryFilter",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, encode_condition_struct(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_consumed_capacity {
    option.Some(v) -> [
      #("ReturnConsumedCapacity", encode_return_consumed_capacity_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.scan_index_forward {
    option.Some(v) -> [#("ScanIndexForward", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.select {
    option.Some(v) -> [#("Select", encode_select_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_query_input_struct_top(input: QueryInput) -> json.Json {
  let pairs = []
  let pairs = case input.attributes_to_get {
    option.Some(v) -> [
      #("AttributesToGet", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.conditional_operator {
    option.Some(v) -> [
      #("ConditionalOperator", encode_conditional_operator_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.consistent_read {
    option.Some(v) -> [#("ConsistentRead", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.exclusive_start_key {
    option.Some(v) -> [
      #(
        "ExclusiveStartKey",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_names {
    option.Some(v) -> [
      #(
        "ExpressionAttributeNames",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_values {
    option.Some(v) -> [
      #(
        "ExpressionAttributeValues",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.filter_expression {
    option.Some(v) -> [#("FilterExpression", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.key_condition_expression {
    option.Some(v) -> [#("KeyConditionExpression", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.key_conditions {
    option.Some(v) -> [
      #(
        "KeyConditions",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, encode_condition_struct(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.limit {
    option.Some(v) -> [#("Limit", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.projection_expression {
    option.Some(v) -> [#("ProjectionExpression", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.query_filter {
    option.Some(v) -> [
      #(
        "QueryFilter",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, encode_condition_struct(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_consumed_capacity {
    option.Some(v) -> [
      #("ReturnConsumedCapacity", encode_return_consumed_capacity_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.scan_index_forward {
    option.Some(v) -> [#("ScanIndexForward", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.select {
    option.Some(v) -> [#("Select", encode_select_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_query_input_struct() -> decode.Decoder(QueryInput) {
  use <- decode.recursive
  use attributes_to_get <- decode.optional_field(
    "AttributesToGet",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  use conditional_operator <- decode.optional_field(
    "ConditionalOperator",
    option.None,
    decode.optional(decode_conditional_operator_enum()),
  )
  use consistent_read <- decode.optional_field(
    "ConsistentRead",
    option.None,
    decode.optional(decode.bool),
  )
  use exclusive_start_key <- decode.optional_field(
    "ExclusiveStartKey",
    option.None,
    decode.optional(decode.dict(decode.string, decode_attribute_value_union())),
  )
  use expression_attribute_names <- decode.optional_field(
    "ExpressionAttributeNames",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use expression_attribute_values <- decode.optional_field(
    "ExpressionAttributeValues",
    option.None,
    decode.optional(decode.dict(decode.string, decode_attribute_value_union())),
  )
  use filter_expression <- decode.optional_field(
    "FilterExpression",
    option.None,
    decode.optional(decode.string),
  )
  use index_name <- decode.optional_field(
    "IndexName",
    option.None,
    decode.optional(decode.string),
  )
  use key_condition_expression <- decode.optional_field(
    "KeyConditionExpression",
    option.None,
    decode.optional(decode.string),
  )
  use key_conditions <- decode.optional_field(
    "KeyConditions",
    option.None,
    decode.optional(decode.dict(decode.string, decode_condition_struct())),
  )
  use limit <- decode.optional_field(
    "Limit",
    option.None,
    decode.optional(decode.int),
  )
  use projection_expression <- decode.optional_field(
    "ProjectionExpression",
    option.None,
    decode.optional(decode.string),
  )
  use query_filter <- decode.optional_field(
    "QueryFilter",
    option.None,
    decode.optional(decode.dict(decode.string, decode_condition_struct())),
  )
  use return_consumed_capacity <- decode.optional_field(
    "ReturnConsumedCapacity",
    option.None,
    decode.optional(decode_return_consumed_capacity_enum()),
  )
  use scan_index_forward <- decode.optional_field(
    "ScanIndexForward",
    option.None,
    decode.optional(decode.bool),
  )
  use select <- decode.optional_field(
    "Select",
    option.None,
    decode.optional(decode_select_enum()),
  )
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(QueryInput(
    attributes_to_get: attributes_to_get,
    conditional_operator: conditional_operator,
    consistent_read: consistent_read,
    exclusive_start_key: exclusive_start_key,
    expression_attribute_names: expression_attribute_names,
    expression_attribute_values: expression_attribute_values,
    filter_expression: filter_expression,
    index_name: index_name,
    key_condition_expression: key_condition_expression,
    key_conditions: key_conditions,
    limit: limit,
    projection_expression: projection_expression,
    query_filter: query_filter,
    return_consumed_capacity: return_consumed_capacity,
    scan_index_forward: scan_index_forward,
    select: select,
    table_name: table_name,
  ))
}

pub type Condition {
  Condition(
    attribute_value_list: option.Option(List(AttributeValue)),
    comparison_operator: option.Option(ComparisonOperator),
  )
}

pub fn condition_default() -> Condition {
  Condition(attribute_value_list: option.None, comparison_operator: option.None)
}

pub fn encode_condition_struct(input: Condition) -> json.Json {
  let pairs = []
  let pairs = case input.attribute_value_list {
    option.Some(v) -> [
      #(
        "AttributeValueList",
        fn(xs) { json.array(xs, encode_attribute_value_union) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.comparison_operator {
    option.Some(v) -> [
      #("ComparisonOperator", encode_comparison_operator_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_condition_struct_top(input: Condition) -> json.Json {
  let pairs = []
  let pairs = case input.attribute_value_list {
    option.Some(v) -> [
      #(
        "AttributeValueList",
        fn(xs) { json.array(xs, encode_attribute_value_union) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.comparison_operator {
    option.Some(v) -> [
      #("ComparisonOperator", encode_comparison_operator_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_condition_struct() -> decode.Decoder(Condition) {
  use <- decode.recursive
  use attribute_value_list <- decode.optional_field(
    "AttributeValueList",
    option.None,
    decode.optional(decode.list(decode_attribute_value_union())),
  )
  use comparison_operator <- decode.optional_field(
    "ComparisonOperator",
    option.None,
    decode.optional(decode_comparison_operator_enum()),
  )
  decode.success(Condition(
    attribute_value_list: attribute_value_list,
    comparison_operator: comparison_operator,
  ))
}

pub type Select {
  SelectAllAttributes
  SelectAllProjectedAttributes
  SelectCount
  SelectSpecificAttributes
}

pub fn encode_select_enum(v: Select) -> json.Json {
  case v {
    SelectAllAttributes -> json.string("ALL_ATTRIBUTES")
    SelectAllProjectedAttributes -> json.string("ALL_PROJECTED_ATTRIBUTES")
    SelectCount -> json.string("COUNT")
    SelectSpecificAttributes -> json.string("SPECIFIC_ATTRIBUTES")
  }
}

pub fn decode_select_enum() -> decode.Decoder(Select) {
  decode.then(decode.string, fn(s) {
    case s {
      "ALL_ATTRIBUTES" -> decode.success(SelectAllAttributes)
      "ALL_PROJECTED_ATTRIBUTES" -> decode.success(SelectAllProjectedAttributes)
      "COUNT" -> decode.success(SelectCount)
      "SPECIFIC_ATTRIBUTES" -> decode.success(SelectSpecificAttributes)
      _ -> decode.failure(SelectAllAttributes, "unknown enum value")
    }
  })
}

pub type QueryOutput {
  QueryOutput(
    consumed_capacity: option.Option(ConsumedCapacity),
    count: option.Option(Int),
    items: option.Option(List(dict.Dict(String, AttributeValue))),
    last_evaluated_key: option.Option(dict.Dict(String, AttributeValue)),
    scanned_count: option.Option(Int),
  )
}

pub fn query_output_default() -> QueryOutput {
  QueryOutput(
    consumed_capacity: option.None,
    count: option.None,
    items: option.None,
    last_evaluated_key: option.None,
    scanned_count: option.None,
  )
}

pub fn encode_query_output_struct(input: QueryOutput) -> json.Json {
  let pairs = []
  let pairs = case input.consumed_capacity {
    option.Some(v) -> [
      #("ConsumedCapacity", encode_consumed_capacity_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.count {
    option.Some(v) -> [#("Count", json.int(v)), ..pairs]
    option.None -> [#("Count", json.int(0)), ..pairs]
  }
  let pairs = case input.items {
    option.Some(v) -> [
      #(
        "Items",
        fn(xs) {
          json.array(xs, fn(d) {
            json.object(
              dict.to_list(d)
              |> list.map(fn(pair) {
                #(pair.0, encode_attribute_value_union(pair.1))
              }),
            )
          })
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.last_evaluated_key {
    option.Some(v) -> [
      #(
        "LastEvaluatedKey",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.scanned_count {
    option.Some(v) -> [#("ScannedCount", json.int(v)), ..pairs]
    option.None -> [#("ScannedCount", json.int(0)), ..pairs]
  }
  json.object(pairs)
}

pub fn encode_query_output_struct_top(input: QueryOutput) -> json.Json {
  let pairs = []
  let pairs = case input.consumed_capacity {
    option.Some(v) -> [
      #("ConsumedCapacity", encode_consumed_capacity_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.count {
    option.Some(v) -> [#("Count", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.items {
    option.Some(v) -> [
      #(
        "Items",
        fn(xs) {
          json.array(xs, fn(d) {
            json.object(
              dict.to_list(d)
              |> list.map(fn(pair) {
                #(pair.0, encode_attribute_value_union(pair.1))
              }),
            )
          })
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.last_evaluated_key {
    option.Some(v) -> [
      #(
        "LastEvaluatedKey",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.scanned_count {
    option.Some(v) -> [#("ScannedCount", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_query_output_struct() -> decode.Decoder(QueryOutput) {
  use <- decode.recursive
  use consumed_capacity <- decode.optional_field(
    "ConsumedCapacity",
    option.None,
    decode.optional(decode_consumed_capacity_struct()),
  )
  use count <- decode.optional_field(
    "Count",
    option.None,
    decode.optional(decode.int),
  )
  use items <- decode.optional_field(
    "Items",
    option.None,
    decode.optional(
      decode.list(decode.dict(decode.string, decode_attribute_value_union())),
    ),
  )
  use last_evaluated_key <- decode.optional_field(
    "LastEvaluatedKey",
    option.None,
    decode.optional(decode.dict(decode.string, decode_attribute_value_union())),
  )
  use scanned_count <- decode.optional_field(
    "ScannedCount",
    option.None,
    decode.optional(decode.int),
  )
  decode.success(QueryOutput(
    consumed_capacity: consumed_capacity,
    count: count,
    items: items,
    last_evaluated_key: last_evaluated_key,
    scanned_count: scanned_count,
  ))
}

pub type RestoreTableFromBackupInput {
  RestoreTableFromBackupInput(
    backup_arn: option.Option(String),
    billing_mode_override: option.Option(BillingMode),
    global_secondary_index_override: option.Option(List(GlobalSecondaryIndex)),
    local_secondary_index_override: option.Option(List(LocalSecondaryIndex)),
    on_demand_throughput_override: option.Option(OnDemandThroughput),
    provisioned_throughput_override: option.Option(ProvisionedThroughput),
    sse_specification_override: option.Option(SSESpecification),
    target_table_name: option.Option(String),
  )
}

pub fn restore_table_from_backup_input_default() -> RestoreTableFromBackupInput {
  RestoreTableFromBackupInput(
    backup_arn: option.None,
    billing_mode_override: option.None,
    global_secondary_index_override: option.None,
    local_secondary_index_override: option.None,
    on_demand_throughput_override: option.None,
    provisioned_throughput_override: option.None,
    sse_specification_override: option.None,
    target_table_name: option.None,
  )
}

pub fn encode_restore_table_from_backup_input_struct(
  input: RestoreTableFromBackupInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.backup_arn {
    option.Some(v) -> [#("BackupArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.billing_mode_override {
    option.Some(v) -> [
      #("BillingModeOverride", encode_billing_mode_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.global_secondary_index_override {
    option.Some(v) -> [
      #(
        "GlobalSecondaryIndexOverride",
        fn(xs) { json.array(xs, encode_global_secondary_index_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.local_secondary_index_override {
    option.Some(v) -> [
      #(
        "LocalSecondaryIndexOverride",
        fn(xs) { json.array(xs, encode_local_secondary_index_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.on_demand_throughput_override {
    option.Some(v) -> [
      #("OnDemandThroughputOverride", encode_on_demand_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_throughput_override {
    option.Some(v) -> [
      #(
        "ProvisionedThroughputOverride",
        encode_provisioned_throughput_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.sse_specification_override {
    option.Some(v) -> [
      #("SSESpecificationOverride", encode_sse_specification_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.target_table_name {
    option.Some(v) -> [#("TargetTableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_restore_table_from_backup_input_struct_top(
  input: RestoreTableFromBackupInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.backup_arn {
    option.Some(v) -> [#("BackupArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.billing_mode_override {
    option.Some(v) -> [
      #("BillingModeOverride", encode_billing_mode_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.global_secondary_index_override {
    option.Some(v) -> [
      #(
        "GlobalSecondaryIndexOverride",
        fn(xs) { json.array(xs, encode_global_secondary_index_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.local_secondary_index_override {
    option.Some(v) -> [
      #(
        "LocalSecondaryIndexOverride",
        fn(xs) { json.array(xs, encode_local_secondary_index_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.on_demand_throughput_override {
    option.Some(v) -> [
      #("OnDemandThroughputOverride", encode_on_demand_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_throughput_override {
    option.Some(v) -> [
      #(
        "ProvisionedThroughputOverride",
        encode_provisioned_throughput_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.sse_specification_override {
    option.Some(v) -> [
      #("SSESpecificationOverride", encode_sse_specification_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.target_table_name {
    option.Some(v) -> [#("TargetTableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_restore_table_from_backup_input_struct() -> decode.Decoder(
  RestoreTableFromBackupInput,
) {
  use <- decode.recursive
  use backup_arn <- decode.optional_field(
    "BackupArn",
    option.None,
    decode.optional(decode.string),
  )
  use billing_mode_override <- decode.optional_field(
    "BillingModeOverride",
    option.None,
    decode.optional(decode_billing_mode_enum()),
  )
  use global_secondary_index_override <- decode.optional_field(
    "GlobalSecondaryIndexOverride",
    option.None,
    decode.optional(decode.list(decode_global_secondary_index_struct())),
  )
  use local_secondary_index_override <- decode.optional_field(
    "LocalSecondaryIndexOverride",
    option.None,
    decode.optional(decode.list(decode_local_secondary_index_struct())),
  )
  use on_demand_throughput_override <- decode.optional_field(
    "OnDemandThroughputOverride",
    option.None,
    decode.optional(decode_on_demand_throughput_struct()),
  )
  use provisioned_throughput_override <- decode.optional_field(
    "ProvisionedThroughputOverride",
    option.None,
    decode.optional(decode_provisioned_throughput_struct()),
  )
  use sse_specification_override <- decode.optional_field(
    "SSESpecificationOverride",
    option.None,
    decode.optional(decode_sse_specification_struct()),
  )
  use target_table_name <- decode.optional_field(
    "TargetTableName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(RestoreTableFromBackupInput(
    backup_arn: backup_arn,
    billing_mode_override: billing_mode_override,
    global_secondary_index_override: global_secondary_index_override,
    local_secondary_index_override: local_secondary_index_override,
    on_demand_throughput_override: on_demand_throughput_override,
    provisioned_throughput_override: provisioned_throughput_override,
    sse_specification_override: sse_specification_override,
    target_table_name: target_table_name,
  ))
}

pub type RestoreTableFromBackupOutput {
  RestoreTableFromBackupOutput(
    table_description: option.Option(TableDescription),
  )
}

pub fn restore_table_from_backup_output_default() -> RestoreTableFromBackupOutput {
  RestoreTableFromBackupOutput(table_description: option.None)
}

pub fn encode_restore_table_from_backup_output_struct(
  input: RestoreTableFromBackupOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.table_description {
    option.Some(v) -> [
      #("TableDescription", encode_table_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_restore_table_from_backup_output_struct_top(
  input: RestoreTableFromBackupOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.table_description {
    option.Some(v) -> [
      #("TableDescription", encode_table_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_restore_table_from_backup_output_struct() -> decode.Decoder(
  RestoreTableFromBackupOutput,
) {
  use <- decode.recursive
  use table_description <- decode.optional_field(
    "TableDescription",
    option.None,
    decode.optional(decode_table_description_struct()),
  )
  decode.success(RestoreTableFromBackupOutput(
    table_description: table_description,
  ))
}

pub type TableAlreadyExistsException {
  TableAlreadyExistsException(message: option.Option(String))
}

pub fn table_already_exists_exception_default() -> TableAlreadyExistsException {
  TableAlreadyExistsException(message: option.None)
}

pub fn encode_table_already_exists_exception_struct(
  input: TableAlreadyExistsException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_table_already_exists_exception_struct_top(
  input: TableAlreadyExistsException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_table_already_exists_exception_struct() -> decode.Decoder(
  TableAlreadyExistsException,
) {
  use <- decode.recursive
  use message <- decode.optional_field(
    "message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(TableAlreadyExistsException(message: message))
}

pub type RestoreTableToPointInTimeInput {
  RestoreTableToPointInTimeInput(
    billing_mode_override: option.Option(BillingMode),
    global_secondary_index_override: option.Option(List(GlobalSecondaryIndex)),
    local_secondary_index_override: option.Option(List(LocalSecondaryIndex)),
    on_demand_throughput_override: option.Option(OnDemandThroughput),
    provisioned_throughput_override: option.Option(ProvisionedThroughput),
    restore_date_time: option.Option(json_timestamp.Timestamp),
    sse_specification_override: option.Option(SSESpecification),
    source_table_arn: option.Option(String),
    source_table_name: option.Option(String),
    target_table_name: option.Option(String),
    use_latest_restorable_time: option.Option(Bool),
  )
}

pub fn restore_table_to_point_in_time_input_default() -> RestoreTableToPointInTimeInput {
  RestoreTableToPointInTimeInput(
    billing_mode_override: option.None,
    global_secondary_index_override: option.None,
    local_secondary_index_override: option.None,
    on_demand_throughput_override: option.None,
    provisioned_throughput_override: option.None,
    restore_date_time: option.None,
    sse_specification_override: option.None,
    source_table_arn: option.None,
    source_table_name: option.None,
    target_table_name: option.None,
    use_latest_restorable_time: option.None,
  )
}

pub fn encode_restore_table_to_point_in_time_input_struct(
  input: RestoreTableToPointInTimeInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.billing_mode_override {
    option.Some(v) -> [
      #("BillingModeOverride", encode_billing_mode_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.global_secondary_index_override {
    option.Some(v) -> [
      #(
        "GlobalSecondaryIndexOverride",
        fn(xs) { json.array(xs, encode_global_secondary_index_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.local_secondary_index_override {
    option.Some(v) -> [
      #(
        "LocalSecondaryIndexOverride",
        fn(xs) { json.array(xs, encode_local_secondary_index_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.on_demand_throughput_override {
    option.Some(v) -> [
      #("OnDemandThroughputOverride", encode_on_demand_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_throughput_override {
    option.Some(v) -> [
      #(
        "ProvisionedThroughputOverride",
        encode_provisioned_throughput_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.restore_date_time {
    option.Some(v) -> [
      #("RestoreDateTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.sse_specification_override {
    option.Some(v) -> [
      #("SSESpecificationOverride", encode_sse_specification_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.source_table_arn {
    option.Some(v) -> [#("SourceTableArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.source_table_name {
    option.Some(v) -> [#("SourceTableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.target_table_name {
    option.Some(v) -> [#("TargetTableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.use_latest_restorable_time {
    option.Some(v) -> [#("UseLatestRestorableTime", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_restore_table_to_point_in_time_input_struct_top(
  input: RestoreTableToPointInTimeInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.billing_mode_override {
    option.Some(v) -> [
      #("BillingModeOverride", encode_billing_mode_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.global_secondary_index_override {
    option.Some(v) -> [
      #(
        "GlobalSecondaryIndexOverride",
        fn(xs) { json.array(xs, encode_global_secondary_index_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.local_secondary_index_override {
    option.Some(v) -> [
      #(
        "LocalSecondaryIndexOverride",
        fn(xs) { json.array(xs, encode_local_secondary_index_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.on_demand_throughput_override {
    option.Some(v) -> [
      #("OnDemandThroughputOverride", encode_on_demand_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_throughput_override {
    option.Some(v) -> [
      #(
        "ProvisionedThroughputOverride",
        encode_provisioned_throughput_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.restore_date_time {
    option.Some(v) -> [
      #("RestoreDateTime", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.sse_specification_override {
    option.Some(v) -> [
      #("SSESpecificationOverride", encode_sse_specification_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.source_table_arn {
    option.Some(v) -> [#("SourceTableArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.source_table_name {
    option.Some(v) -> [#("SourceTableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.target_table_name {
    option.Some(v) -> [#("TargetTableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.use_latest_restorable_time {
    option.Some(v) -> [#("UseLatestRestorableTime", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_restore_table_to_point_in_time_input_struct() -> decode.Decoder(
  RestoreTableToPointInTimeInput,
) {
  use <- decode.recursive
  use billing_mode_override <- decode.optional_field(
    "BillingModeOverride",
    option.None,
    decode.optional(decode_billing_mode_enum()),
  )
  use global_secondary_index_override <- decode.optional_field(
    "GlobalSecondaryIndexOverride",
    option.None,
    decode.optional(decode.list(decode_global_secondary_index_struct())),
  )
  use local_secondary_index_override <- decode.optional_field(
    "LocalSecondaryIndexOverride",
    option.None,
    decode.optional(decode.list(decode_local_secondary_index_struct())),
  )
  use on_demand_throughput_override <- decode.optional_field(
    "OnDemandThroughputOverride",
    option.None,
    decode.optional(decode_on_demand_throughput_struct()),
  )
  use provisioned_throughput_override <- decode.optional_field(
    "ProvisionedThroughputOverride",
    option.None,
    decode.optional(decode_provisioned_throughput_struct()),
  )
  use restore_date_time <- decode.optional_field(
    "RestoreDateTime",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use sse_specification_override <- decode.optional_field(
    "SSESpecificationOverride",
    option.None,
    decode.optional(decode_sse_specification_struct()),
  )
  use source_table_arn <- decode.optional_field(
    "SourceTableArn",
    option.None,
    decode.optional(decode.string),
  )
  use source_table_name <- decode.optional_field(
    "SourceTableName",
    option.None,
    decode.optional(decode.string),
  )
  use target_table_name <- decode.optional_field(
    "TargetTableName",
    option.None,
    decode.optional(decode.string),
  )
  use use_latest_restorable_time <- decode.optional_field(
    "UseLatestRestorableTime",
    option.None,
    decode.optional(decode.bool),
  )
  decode.success(RestoreTableToPointInTimeInput(
    billing_mode_override: billing_mode_override,
    global_secondary_index_override: global_secondary_index_override,
    local_secondary_index_override: local_secondary_index_override,
    on_demand_throughput_override: on_demand_throughput_override,
    provisioned_throughput_override: provisioned_throughput_override,
    restore_date_time: restore_date_time,
    sse_specification_override: sse_specification_override,
    source_table_arn: source_table_arn,
    source_table_name: source_table_name,
    target_table_name: target_table_name,
    use_latest_restorable_time: use_latest_restorable_time,
  ))
}

pub type RestoreTableToPointInTimeOutput {
  RestoreTableToPointInTimeOutput(
    table_description: option.Option(TableDescription),
  )
}

pub fn restore_table_to_point_in_time_output_default() -> RestoreTableToPointInTimeOutput {
  RestoreTableToPointInTimeOutput(table_description: option.None)
}

pub fn encode_restore_table_to_point_in_time_output_struct(
  input: RestoreTableToPointInTimeOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.table_description {
    option.Some(v) -> [
      #("TableDescription", encode_table_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_restore_table_to_point_in_time_output_struct_top(
  input: RestoreTableToPointInTimeOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.table_description {
    option.Some(v) -> [
      #("TableDescription", encode_table_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_restore_table_to_point_in_time_output_struct() -> decode.Decoder(
  RestoreTableToPointInTimeOutput,
) {
  use <- decode.recursive
  use table_description <- decode.optional_field(
    "TableDescription",
    option.None,
    decode.optional(decode_table_description_struct()),
  )
  decode.success(RestoreTableToPointInTimeOutput(
    table_description: table_description,
  ))
}

pub type InvalidRestoreTimeException {
  InvalidRestoreTimeException(message: option.Option(String))
}

pub fn invalid_restore_time_exception_default() -> InvalidRestoreTimeException {
  InvalidRestoreTimeException(message: option.None)
}

pub fn encode_invalid_restore_time_exception_struct(
  input: InvalidRestoreTimeException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_invalid_restore_time_exception_struct_top(
  input: InvalidRestoreTimeException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_invalid_restore_time_exception_struct() -> decode.Decoder(
  InvalidRestoreTimeException,
) {
  use <- decode.recursive
  use message <- decode.optional_field(
    "message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(InvalidRestoreTimeException(message: message))
}

pub type ScanInput {
  ScanInput(
    attributes_to_get: option.Option(List(String)),
    conditional_operator: option.Option(ConditionalOperator),
    consistent_read: option.Option(Bool),
    exclusive_start_key: option.Option(dict.Dict(String, AttributeValue)),
    expression_attribute_names: option.Option(dict.Dict(String, String)),
    expression_attribute_values: option.Option(
      dict.Dict(String, AttributeValue),
    ),
    filter_expression: option.Option(String),
    index_name: option.Option(String),
    limit: option.Option(Int),
    projection_expression: option.Option(String),
    return_consumed_capacity: option.Option(ReturnConsumedCapacity),
    scan_filter: option.Option(dict.Dict(String, Condition)),
    segment: option.Option(Int),
    select: option.Option(Select),
    table_name: option.Option(String),
    total_segments: option.Option(Int),
  )
}

pub fn scan_input_default() -> ScanInput {
  ScanInput(
    attributes_to_get: option.None,
    conditional_operator: option.None,
    consistent_read: option.None,
    exclusive_start_key: option.None,
    expression_attribute_names: option.None,
    expression_attribute_values: option.None,
    filter_expression: option.None,
    index_name: option.None,
    limit: option.None,
    projection_expression: option.None,
    return_consumed_capacity: option.None,
    scan_filter: option.None,
    segment: option.None,
    select: option.None,
    table_name: option.None,
    total_segments: option.None,
  )
}

pub fn encode_scan_input_struct(input: ScanInput) -> json.Json {
  let pairs = []
  let pairs = case input.attributes_to_get {
    option.Some(v) -> [
      #("AttributesToGet", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.conditional_operator {
    option.Some(v) -> [
      #("ConditionalOperator", encode_conditional_operator_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.consistent_read {
    option.Some(v) -> [#("ConsistentRead", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.exclusive_start_key {
    option.Some(v) -> [
      #(
        "ExclusiveStartKey",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_names {
    option.Some(v) -> [
      #(
        "ExpressionAttributeNames",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_values {
    option.Some(v) -> [
      #(
        "ExpressionAttributeValues",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.filter_expression {
    option.Some(v) -> [#("FilterExpression", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.limit {
    option.Some(v) -> [#("Limit", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.projection_expression {
    option.Some(v) -> [#("ProjectionExpression", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.return_consumed_capacity {
    option.Some(v) -> [
      #("ReturnConsumedCapacity", encode_return_consumed_capacity_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.scan_filter {
    option.Some(v) -> [
      #(
        "ScanFilter",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, encode_condition_struct(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.segment {
    option.Some(v) -> [#("Segment", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.select {
    option.Some(v) -> [#("Select", encode_select_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.total_segments {
    option.Some(v) -> [#("TotalSegments", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_scan_input_struct_top(input: ScanInput) -> json.Json {
  let pairs = []
  let pairs = case input.attributes_to_get {
    option.Some(v) -> [
      #("AttributesToGet", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.conditional_operator {
    option.Some(v) -> [
      #("ConditionalOperator", encode_conditional_operator_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.consistent_read {
    option.Some(v) -> [#("ConsistentRead", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.exclusive_start_key {
    option.Some(v) -> [
      #(
        "ExclusiveStartKey",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_names {
    option.Some(v) -> [
      #(
        "ExpressionAttributeNames",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_values {
    option.Some(v) -> [
      #(
        "ExpressionAttributeValues",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.filter_expression {
    option.Some(v) -> [#("FilterExpression", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.limit {
    option.Some(v) -> [#("Limit", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.projection_expression {
    option.Some(v) -> [#("ProjectionExpression", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.return_consumed_capacity {
    option.Some(v) -> [
      #("ReturnConsumedCapacity", encode_return_consumed_capacity_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.scan_filter {
    option.Some(v) -> [
      #(
        "ScanFilter",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, encode_condition_struct(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.segment {
    option.Some(v) -> [#("Segment", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.select {
    option.Some(v) -> [#("Select", encode_select_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.total_segments {
    option.Some(v) -> [#("TotalSegments", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_scan_input_struct() -> decode.Decoder(ScanInput) {
  use <- decode.recursive
  use attributes_to_get <- decode.optional_field(
    "AttributesToGet",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  use conditional_operator <- decode.optional_field(
    "ConditionalOperator",
    option.None,
    decode.optional(decode_conditional_operator_enum()),
  )
  use consistent_read <- decode.optional_field(
    "ConsistentRead",
    option.None,
    decode.optional(decode.bool),
  )
  use exclusive_start_key <- decode.optional_field(
    "ExclusiveStartKey",
    option.None,
    decode.optional(decode.dict(decode.string, decode_attribute_value_union())),
  )
  use expression_attribute_names <- decode.optional_field(
    "ExpressionAttributeNames",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use expression_attribute_values <- decode.optional_field(
    "ExpressionAttributeValues",
    option.None,
    decode.optional(decode.dict(decode.string, decode_attribute_value_union())),
  )
  use filter_expression <- decode.optional_field(
    "FilterExpression",
    option.None,
    decode.optional(decode.string),
  )
  use index_name <- decode.optional_field(
    "IndexName",
    option.None,
    decode.optional(decode.string),
  )
  use limit <- decode.optional_field(
    "Limit",
    option.None,
    decode.optional(decode.int),
  )
  use projection_expression <- decode.optional_field(
    "ProjectionExpression",
    option.None,
    decode.optional(decode.string),
  )
  use return_consumed_capacity <- decode.optional_field(
    "ReturnConsumedCapacity",
    option.None,
    decode.optional(decode_return_consumed_capacity_enum()),
  )
  use scan_filter <- decode.optional_field(
    "ScanFilter",
    option.None,
    decode.optional(decode.dict(decode.string, decode_condition_struct())),
  )
  use segment <- decode.optional_field(
    "Segment",
    option.None,
    decode.optional(decode.int),
  )
  use select <- decode.optional_field(
    "Select",
    option.None,
    decode.optional(decode_select_enum()),
  )
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  use total_segments <- decode.optional_field(
    "TotalSegments",
    option.None,
    decode.optional(decode.int),
  )
  decode.success(ScanInput(
    attributes_to_get: attributes_to_get,
    conditional_operator: conditional_operator,
    consistent_read: consistent_read,
    exclusive_start_key: exclusive_start_key,
    expression_attribute_names: expression_attribute_names,
    expression_attribute_values: expression_attribute_values,
    filter_expression: filter_expression,
    index_name: index_name,
    limit: limit,
    projection_expression: projection_expression,
    return_consumed_capacity: return_consumed_capacity,
    scan_filter: scan_filter,
    segment: segment,
    select: select,
    table_name: table_name,
    total_segments: total_segments,
  ))
}

pub type ScanOutput {
  ScanOutput(
    consumed_capacity: option.Option(ConsumedCapacity),
    count: option.Option(Int),
    items: option.Option(List(dict.Dict(String, AttributeValue))),
    last_evaluated_key: option.Option(dict.Dict(String, AttributeValue)),
    scanned_count: option.Option(Int),
  )
}

pub fn scan_output_default() -> ScanOutput {
  ScanOutput(
    consumed_capacity: option.None,
    count: option.None,
    items: option.None,
    last_evaluated_key: option.None,
    scanned_count: option.None,
  )
}

pub fn encode_scan_output_struct(input: ScanOutput) -> json.Json {
  let pairs = []
  let pairs = case input.consumed_capacity {
    option.Some(v) -> [
      #("ConsumedCapacity", encode_consumed_capacity_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.count {
    option.Some(v) -> [#("Count", json.int(v)), ..pairs]
    option.None -> [#("Count", json.int(0)), ..pairs]
  }
  let pairs = case input.items {
    option.Some(v) -> [
      #(
        "Items",
        fn(xs) {
          json.array(xs, fn(d) {
            json.object(
              dict.to_list(d)
              |> list.map(fn(pair) {
                #(pair.0, encode_attribute_value_union(pair.1))
              }),
            )
          })
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.last_evaluated_key {
    option.Some(v) -> [
      #(
        "LastEvaluatedKey",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.scanned_count {
    option.Some(v) -> [#("ScannedCount", json.int(v)), ..pairs]
    option.None -> [#("ScannedCount", json.int(0)), ..pairs]
  }
  json.object(pairs)
}

pub fn encode_scan_output_struct_top(input: ScanOutput) -> json.Json {
  let pairs = []
  let pairs = case input.consumed_capacity {
    option.Some(v) -> [
      #("ConsumedCapacity", encode_consumed_capacity_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.count {
    option.Some(v) -> [#("Count", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.items {
    option.Some(v) -> [
      #(
        "Items",
        fn(xs) {
          json.array(xs, fn(d) {
            json.object(
              dict.to_list(d)
              |> list.map(fn(pair) {
                #(pair.0, encode_attribute_value_union(pair.1))
              }),
            )
          })
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.last_evaluated_key {
    option.Some(v) -> [
      #(
        "LastEvaluatedKey",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.scanned_count {
    option.Some(v) -> [#("ScannedCount", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_scan_output_struct() -> decode.Decoder(ScanOutput) {
  use <- decode.recursive
  use consumed_capacity <- decode.optional_field(
    "ConsumedCapacity",
    option.None,
    decode.optional(decode_consumed_capacity_struct()),
  )
  use count <- decode.optional_field(
    "Count",
    option.None,
    decode.optional(decode.int),
  )
  use items <- decode.optional_field(
    "Items",
    option.None,
    decode.optional(
      decode.list(decode.dict(decode.string, decode_attribute_value_union())),
    ),
  )
  use last_evaluated_key <- decode.optional_field(
    "LastEvaluatedKey",
    option.None,
    decode.optional(decode.dict(decode.string, decode_attribute_value_union())),
  )
  use scanned_count <- decode.optional_field(
    "ScannedCount",
    option.None,
    decode.optional(decode.int),
  )
  decode.success(ScanOutput(
    consumed_capacity: consumed_capacity,
    count: count,
    items: items,
    last_evaluated_key: last_evaluated_key,
    scanned_count: scanned_count,
  ))
}

pub type TagResourceInput {
  TagResourceInput(
    resource_arn: option.Option(String),
    tags: option.Option(List(Tag)),
  )
}

pub fn tag_resource_input_default() -> TagResourceInput {
  TagResourceInput(resource_arn: option.None, tags: option.None)
}

pub fn encode_tag_resource_input_struct(input: TagResourceInput) -> json.Json {
  let pairs = []
  let pairs = case input.resource_arn {
    option.Some(v) -> [#("ResourceArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.tags {
    option.Some(v) -> [
      #("Tags", fn(xs) { json.array(xs, encode_tag_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_tag_resource_input_struct_top(
  input: TagResourceInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.resource_arn {
    option.Some(v) -> [#("ResourceArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.tags {
    option.Some(v) -> [
      #("Tags", fn(xs) { json.array(xs, encode_tag_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_tag_resource_input_struct() -> decode.Decoder(TagResourceInput) {
  use <- decode.recursive
  use resource_arn <- decode.optional_field(
    "ResourceArn",
    option.None,
    decode.optional(decode.string),
  )
  use tags <- decode.optional_field(
    "Tags",
    option.None,
    decode.optional(decode.list(decode_tag_struct())),
  )
  decode.success(TagResourceInput(resource_arn: resource_arn, tags: tags))
}

pub type TransactGetItemsInput {
  TransactGetItemsInput(
    return_consumed_capacity: option.Option(ReturnConsumedCapacity),
    transact_items: option.Option(List(TransactGetItem)),
  )
}

pub fn transact_get_items_input_default() -> TransactGetItemsInput {
  TransactGetItemsInput(
    return_consumed_capacity: option.None,
    transact_items: option.None,
  )
}

pub fn encode_transact_get_items_input_struct(
  input: TransactGetItemsInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.return_consumed_capacity {
    option.Some(v) -> [
      #("ReturnConsumedCapacity", encode_return_consumed_capacity_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.transact_items {
    option.Some(v) -> [
      #(
        "TransactItems",
        fn(xs) { json.array(xs, encode_transact_get_item_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_transact_get_items_input_struct_top(
  input: TransactGetItemsInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.return_consumed_capacity {
    option.Some(v) -> [
      #("ReturnConsumedCapacity", encode_return_consumed_capacity_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.transact_items {
    option.Some(v) -> [
      #(
        "TransactItems",
        fn(xs) { json.array(xs, encode_transact_get_item_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_transact_get_items_input_struct() -> decode.Decoder(
  TransactGetItemsInput,
) {
  use <- decode.recursive
  use return_consumed_capacity <- decode.optional_field(
    "ReturnConsumedCapacity",
    option.None,
    decode.optional(decode_return_consumed_capacity_enum()),
  )
  use transact_items <- decode.optional_field(
    "TransactItems",
    option.None,
    decode.optional(decode.list(decode_transact_get_item_struct())),
  )
  decode.success(TransactGetItemsInput(
    return_consumed_capacity: return_consumed_capacity,
    transact_items: transact_items,
  ))
}

pub type TransactGetItem {
  TransactGetItem(get: option.Option(Get))
}

pub fn transact_get_item_default() -> TransactGetItem {
  TransactGetItem(get: option.None)
}

pub fn encode_transact_get_item_struct(input: TransactGetItem) -> json.Json {
  let pairs = []
  let pairs = case input.get {
    option.Some(v) -> [#("Get", encode_get_struct(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_transact_get_item_struct_top(
  input: TransactGetItem,
) -> json.Json {
  let pairs = []
  let pairs = case input.get {
    option.Some(v) -> [#("Get", encode_get_struct(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_transact_get_item_struct() -> decode.Decoder(TransactGetItem) {
  use <- decode.recursive
  use get <- decode.optional_field(
    "Get",
    option.None,
    decode.optional(decode_get_struct()),
  )
  decode.success(TransactGetItem(get: get))
}

pub type Get {
  Get(
    expression_attribute_names: option.Option(dict.Dict(String, String)),
    key: option.Option(dict.Dict(String, AttributeValue)),
    projection_expression: option.Option(String),
    table_name: option.Option(String),
  )
}

pub fn get_default() -> Get {
  Get(
    expression_attribute_names: option.None,
    key: option.None,
    projection_expression: option.None,
    table_name: option.None,
  )
}

pub fn encode_get_struct(input: Get) -> json.Json {
  let pairs = []
  let pairs = case input.expression_attribute_names {
    option.Some(v) -> [
      #(
        "ExpressionAttributeNames",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.key {
    option.Some(v) -> [
      #(
        "Key",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.projection_expression {
    option.Some(v) -> [#("ProjectionExpression", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_get_struct_top(input: Get) -> json.Json {
  let pairs = []
  let pairs = case input.expression_attribute_names {
    option.Some(v) -> [
      #(
        "ExpressionAttributeNames",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.key {
    option.Some(v) -> [
      #(
        "Key",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.projection_expression {
    option.Some(v) -> [#("ProjectionExpression", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_struct() -> decode.Decoder(Get) {
  use <- decode.recursive
  use expression_attribute_names <- decode.optional_field(
    "ExpressionAttributeNames",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use key <- decode.optional_field(
    "Key",
    option.None,
    decode.optional(decode.dict(decode.string, decode_attribute_value_union())),
  )
  use projection_expression <- decode.optional_field(
    "ProjectionExpression",
    option.None,
    decode.optional(decode.string),
  )
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(Get(
    expression_attribute_names: expression_attribute_names,
    key: key,
    projection_expression: projection_expression,
    table_name: table_name,
  ))
}

pub type TransactGetItemsOutput {
  TransactGetItemsOutput(
    consumed_capacity: option.Option(List(ConsumedCapacity)),
    responses: option.Option(List(ItemResponse)),
  )
}

pub fn transact_get_items_output_default() -> TransactGetItemsOutput {
  TransactGetItemsOutput(consumed_capacity: option.None, responses: option.None)
}

pub fn encode_transact_get_items_output_struct(
  input: TransactGetItemsOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.consumed_capacity {
    option.Some(v) -> [
      #(
        "ConsumedCapacity",
        fn(xs) { json.array(xs, encode_consumed_capacity_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.responses {
    option.Some(v) -> [
      #("Responses", fn(xs) { json.array(xs, encode_item_response_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_transact_get_items_output_struct_top(
  input: TransactGetItemsOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.consumed_capacity {
    option.Some(v) -> [
      #(
        "ConsumedCapacity",
        fn(xs) { json.array(xs, encode_consumed_capacity_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.responses {
    option.Some(v) -> [
      #("Responses", fn(xs) { json.array(xs, encode_item_response_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_transact_get_items_output_struct() -> decode.Decoder(
  TransactGetItemsOutput,
) {
  use <- decode.recursive
  use consumed_capacity <- decode.optional_field(
    "ConsumedCapacity",
    option.None,
    decode.optional(decode.list(decode_consumed_capacity_struct())),
  )
  use responses <- decode.optional_field(
    "Responses",
    option.None,
    decode.optional(decode.list(decode_item_response_struct())),
  )
  decode.success(TransactGetItemsOutput(
    consumed_capacity: consumed_capacity,
    responses: responses,
  ))
}

pub type TransactWriteItemsInput {
  TransactWriteItemsInput(
    client_request_token: option.Option(String),
    return_consumed_capacity: option.Option(ReturnConsumedCapacity),
    return_item_collection_metrics: option.Option(ReturnItemCollectionMetrics),
    transact_items: option.Option(List(TransactWriteItem)),
  )
}

pub fn transact_write_items_input_default() -> TransactWriteItemsInput {
  TransactWriteItemsInput(
    client_request_token: option.None,
    return_consumed_capacity: option.None,
    return_item_collection_metrics: option.None,
    transact_items: option.None,
  )
}

pub fn encode_transact_write_items_input_struct(
  input: TransactWriteItemsInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.client_request_token {
    option.Some(v) -> [#("ClientRequestToken", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.return_consumed_capacity {
    option.Some(v) -> [
      #("ReturnConsumedCapacity", encode_return_consumed_capacity_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_item_collection_metrics {
    option.Some(v) -> [
      #(
        "ReturnItemCollectionMetrics",
        encode_return_item_collection_metrics_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.transact_items {
    option.Some(v) -> [
      #(
        "TransactItems",
        fn(xs) { json.array(xs, encode_transact_write_item_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_transact_write_items_input_struct_top(
  input: TransactWriteItemsInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.client_request_token {
    option.Some(v) -> [#("ClientRequestToken", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.return_consumed_capacity {
    option.Some(v) -> [
      #("ReturnConsumedCapacity", encode_return_consumed_capacity_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_item_collection_metrics {
    option.Some(v) -> [
      #(
        "ReturnItemCollectionMetrics",
        encode_return_item_collection_metrics_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.transact_items {
    option.Some(v) -> [
      #(
        "TransactItems",
        fn(xs) { json.array(xs, encode_transact_write_item_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_transact_write_items_input_struct() -> decode.Decoder(
  TransactWriteItemsInput,
) {
  use <- decode.recursive
  use client_request_token <- decode.optional_field(
    "ClientRequestToken",
    option.None,
    decode.optional(decode.string),
  )
  use return_consumed_capacity <- decode.optional_field(
    "ReturnConsumedCapacity",
    option.None,
    decode.optional(decode_return_consumed_capacity_enum()),
  )
  use return_item_collection_metrics <- decode.optional_field(
    "ReturnItemCollectionMetrics",
    option.None,
    decode.optional(decode_return_item_collection_metrics_enum()),
  )
  use transact_items <- decode.optional_field(
    "TransactItems",
    option.None,
    decode.optional(decode.list(decode_transact_write_item_struct())),
  )
  decode.success(TransactWriteItemsInput(
    client_request_token: client_request_token,
    return_consumed_capacity: return_consumed_capacity,
    return_item_collection_metrics: return_item_collection_metrics,
    transact_items: transact_items,
  ))
}

pub type TransactWriteItem {
  TransactWriteItem(
    condition_check: option.Option(ConditionCheck),
    delete: option.Option(Delete),
    put: option.Option(Put),
    update: option.Option(Update),
  )
}

pub fn transact_write_item_default() -> TransactWriteItem {
  TransactWriteItem(
    condition_check: option.None,
    delete: option.None,
    put: option.None,
    update: option.None,
  )
}

pub fn encode_transact_write_item_struct(
  input: TransactWriteItem,
) -> json.Json {
  let pairs = []
  let pairs = case input.condition_check {
    option.Some(v) -> [
      #("ConditionCheck", encode_condition_check_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.delete {
    option.Some(v) -> [#("Delete", encode_delete_struct(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.put {
    option.Some(v) -> [#("Put", encode_put_struct(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.update {
    option.Some(v) -> [#("Update", encode_update_struct(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_transact_write_item_struct_top(
  input: TransactWriteItem,
) -> json.Json {
  let pairs = []
  let pairs = case input.condition_check {
    option.Some(v) -> [
      #("ConditionCheck", encode_condition_check_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.delete {
    option.Some(v) -> [#("Delete", encode_delete_struct(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.put {
    option.Some(v) -> [#("Put", encode_put_struct(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.update {
    option.Some(v) -> [#("Update", encode_update_struct(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_transact_write_item_struct() -> decode.Decoder(TransactWriteItem) {
  use <- decode.recursive
  use condition_check <- decode.optional_field(
    "ConditionCheck",
    option.None,
    decode.optional(decode_condition_check_struct()),
  )
  use delete <- decode.optional_field(
    "Delete",
    option.None,
    decode.optional(decode_delete_struct()),
  )
  use put <- decode.optional_field(
    "Put",
    option.None,
    decode.optional(decode_put_struct()),
  )
  use update <- decode.optional_field(
    "Update",
    option.None,
    decode.optional(decode_update_struct()),
  )
  decode.success(TransactWriteItem(
    condition_check: condition_check,
    delete: delete,
    put: put,
    update: update,
  ))
}

pub type ConditionCheck {
  ConditionCheck(
    condition_expression: option.Option(String),
    expression_attribute_names: option.Option(dict.Dict(String, String)),
    expression_attribute_values: option.Option(
      dict.Dict(String, AttributeValue),
    ),
    key: option.Option(dict.Dict(String, AttributeValue)),
    return_values_on_condition_check_failure: option.Option(
      ReturnValuesOnConditionCheckFailure,
    ),
    table_name: option.Option(String),
  )
}

pub fn condition_check_default() -> ConditionCheck {
  ConditionCheck(
    condition_expression: option.None,
    expression_attribute_names: option.None,
    expression_attribute_values: option.None,
    key: option.None,
    return_values_on_condition_check_failure: option.None,
    table_name: option.None,
  )
}

pub fn encode_condition_check_struct(input: ConditionCheck) -> json.Json {
  let pairs = []
  let pairs = case input.condition_expression {
    option.Some(v) -> [#("ConditionExpression", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_names {
    option.Some(v) -> [
      #(
        "ExpressionAttributeNames",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_values {
    option.Some(v) -> [
      #(
        "ExpressionAttributeValues",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.key {
    option.Some(v) -> [
      #(
        "Key",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_values_on_condition_check_failure {
    option.Some(v) -> [
      #(
        "ReturnValuesOnConditionCheckFailure",
        encode_return_values_on_condition_check_failure_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_condition_check_struct_top(input: ConditionCheck) -> json.Json {
  let pairs = []
  let pairs = case input.condition_expression {
    option.Some(v) -> [#("ConditionExpression", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_names {
    option.Some(v) -> [
      #(
        "ExpressionAttributeNames",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_values {
    option.Some(v) -> [
      #(
        "ExpressionAttributeValues",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.key {
    option.Some(v) -> [
      #(
        "Key",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_values_on_condition_check_failure {
    option.Some(v) -> [
      #(
        "ReturnValuesOnConditionCheckFailure",
        encode_return_values_on_condition_check_failure_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_condition_check_struct() -> decode.Decoder(ConditionCheck) {
  use <- decode.recursive
  use condition_expression <- decode.optional_field(
    "ConditionExpression",
    option.None,
    decode.optional(decode.string),
  )
  use expression_attribute_names <- decode.optional_field(
    "ExpressionAttributeNames",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use expression_attribute_values <- decode.optional_field(
    "ExpressionAttributeValues",
    option.None,
    decode.optional(decode.dict(decode.string, decode_attribute_value_union())),
  )
  use key <- decode.optional_field(
    "Key",
    option.None,
    decode.optional(decode.dict(decode.string, decode_attribute_value_union())),
  )
  use return_values_on_condition_check_failure <- decode.optional_field(
    "ReturnValuesOnConditionCheckFailure",
    option.None,
    decode.optional(decode_return_values_on_condition_check_failure_enum()),
  )
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ConditionCheck(
    condition_expression: condition_expression,
    expression_attribute_names: expression_attribute_names,
    expression_attribute_values: expression_attribute_values,
    key: key,
    return_values_on_condition_check_failure: return_values_on_condition_check_failure,
    table_name: table_name,
  ))
}

pub type Delete {
  Delete(
    condition_expression: option.Option(String),
    expression_attribute_names: option.Option(dict.Dict(String, String)),
    expression_attribute_values: option.Option(
      dict.Dict(String, AttributeValue),
    ),
    key: option.Option(dict.Dict(String, AttributeValue)),
    return_values_on_condition_check_failure: option.Option(
      ReturnValuesOnConditionCheckFailure,
    ),
    table_name: option.Option(String),
  )
}

pub fn delete_default() -> Delete {
  Delete(
    condition_expression: option.None,
    expression_attribute_names: option.None,
    expression_attribute_values: option.None,
    key: option.None,
    return_values_on_condition_check_failure: option.None,
    table_name: option.None,
  )
}

pub fn encode_delete_struct(input: Delete) -> json.Json {
  let pairs = []
  let pairs = case input.condition_expression {
    option.Some(v) -> [#("ConditionExpression", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_names {
    option.Some(v) -> [
      #(
        "ExpressionAttributeNames",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_values {
    option.Some(v) -> [
      #(
        "ExpressionAttributeValues",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.key {
    option.Some(v) -> [
      #(
        "Key",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_values_on_condition_check_failure {
    option.Some(v) -> [
      #(
        "ReturnValuesOnConditionCheckFailure",
        encode_return_values_on_condition_check_failure_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_delete_struct_top(input: Delete) -> json.Json {
  let pairs = []
  let pairs = case input.condition_expression {
    option.Some(v) -> [#("ConditionExpression", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_names {
    option.Some(v) -> [
      #(
        "ExpressionAttributeNames",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_values {
    option.Some(v) -> [
      #(
        "ExpressionAttributeValues",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.key {
    option.Some(v) -> [
      #(
        "Key",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_values_on_condition_check_failure {
    option.Some(v) -> [
      #(
        "ReturnValuesOnConditionCheckFailure",
        encode_return_values_on_condition_check_failure_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_delete_struct() -> decode.Decoder(Delete) {
  use <- decode.recursive
  use condition_expression <- decode.optional_field(
    "ConditionExpression",
    option.None,
    decode.optional(decode.string),
  )
  use expression_attribute_names <- decode.optional_field(
    "ExpressionAttributeNames",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use expression_attribute_values <- decode.optional_field(
    "ExpressionAttributeValues",
    option.None,
    decode.optional(decode.dict(decode.string, decode_attribute_value_union())),
  )
  use key <- decode.optional_field(
    "Key",
    option.None,
    decode.optional(decode.dict(decode.string, decode_attribute_value_union())),
  )
  use return_values_on_condition_check_failure <- decode.optional_field(
    "ReturnValuesOnConditionCheckFailure",
    option.None,
    decode.optional(decode_return_values_on_condition_check_failure_enum()),
  )
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(Delete(
    condition_expression: condition_expression,
    expression_attribute_names: expression_attribute_names,
    expression_attribute_values: expression_attribute_values,
    key: key,
    return_values_on_condition_check_failure: return_values_on_condition_check_failure,
    table_name: table_name,
  ))
}

pub type Put {
  Put(
    condition_expression: option.Option(String),
    expression_attribute_names: option.Option(dict.Dict(String, String)),
    expression_attribute_values: option.Option(
      dict.Dict(String, AttributeValue),
    ),
    item: option.Option(dict.Dict(String, AttributeValue)),
    return_values_on_condition_check_failure: option.Option(
      ReturnValuesOnConditionCheckFailure,
    ),
    table_name: option.Option(String),
  )
}

pub fn put_default() -> Put {
  Put(
    condition_expression: option.None,
    expression_attribute_names: option.None,
    expression_attribute_values: option.None,
    item: option.None,
    return_values_on_condition_check_failure: option.None,
    table_name: option.None,
  )
}

pub fn encode_put_struct(input: Put) -> json.Json {
  let pairs = []
  let pairs = case input.condition_expression {
    option.Some(v) -> [#("ConditionExpression", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_names {
    option.Some(v) -> [
      #(
        "ExpressionAttributeNames",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_values {
    option.Some(v) -> [
      #(
        "ExpressionAttributeValues",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.item {
    option.Some(v) -> [
      #(
        "Item",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_values_on_condition_check_failure {
    option.Some(v) -> [
      #(
        "ReturnValuesOnConditionCheckFailure",
        encode_return_values_on_condition_check_failure_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_put_struct_top(input: Put) -> json.Json {
  let pairs = []
  let pairs = case input.condition_expression {
    option.Some(v) -> [#("ConditionExpression", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_names {
    option.Some(v) -> [
      #(
        "ExpressionAttributeNames",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_values {
    option.Some(v) -> [
      #(
        "ExpressionAttributeValues",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.item {
    option.Some(v) -> [
      #(
        "Item",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_values_on_condition_check_failure {
    option.Some(v) -> [
      #(
        "ReturnValuesOnConditionCheckFailure",
        encode_return_values_on_condition_check_failure_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_put_struct() -> decode.Decoder(Put) {
  use <- decode.recursive
  use condition_expression <- decode.optional_field(
    "ConditionExpression",
    option.None,
    decode.optional(decode.string),
  )
  use expression_attribute_names <- decode.optional_field(
    "ExpressionAttributeNames",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use expression_attribute_values <- decode.optional_field(
    "ExpressionAttributeValues",
    option.None,
    decode.optional(decode.dict(decode.string, decode_attribute_value_union())),
  )
  use item <- decode.optional_field(
    "Item",
    option.None,
    decode.optional(decode.dict(decode.string, decode_attribute_value_union())),
  )
  use return_values_on_condition_check_failure <- decode.optional_field(
    "ReturnValuesOnConditionCheckFailure",
    option.None,
    decode.optional(decode_return_values_on_condition_check_failure_enum()),
  )
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(Put(
    condition_expression: condition_expression,
    expression_attribute_names: expression_attribute_names,
    expression_attribute_values: expression_attribute_values,
    item: item,
    return_values_on_condition_check_failure: return_values_on_condition_check_failure,
    table_name: table_name,
  ))
}

pub type Update {
  Update(
    condition_expression: option.Option(String),
    expression_attribute_names: option.Option(dict.Dict(String, String)),
    expression_attribute_values: option.Option(
      dict.Dict(String, AttributeValue),
    ),
    key: option.Option(dict.Dict(String, AttributeValue)),
    return_values_on_condition_check_failure: option.Option(
      ReturnValuesOnConditionCheckFailure,
    ),
    table_name: option.Option(String),
    update_expression: option.Option(String),
  )
}

pub fn update_default() -> Update {
  Update(
    condition_expression: option.None,
    expression_attribute_names: option.None,
    expression_attribute_values: option.None,
    key: option.None,
    return_values_on_condition_check_failure: option.None,
    table_name: option.None,
    update_expression: option.None,
  )
}

pub fn encode_update_struct(input: Update) -> json.Json {
  let pairs = []
  let pairs = case input.condition_expression {
    option.Some(v) -> [#("ConditionExpression", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_names {
    option.Some(v) -> [
      #(
        "ExpressionAttributeNames",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_values {
    option.Some(v) -> [
      #(
        "ExpressionAttributeValues",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.key {
    option.Some(v) -> [
      #(
        "Key",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_values_on_condition_check_failure {
    option.Some(v) -> [
      #(
        "ReturnValuesOnConditionCheckFailure",
        encode_return_values_on_condition_check_failure_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.update_expression {
    option.Some(v) -> [#("UpdateExpression", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_update_struct_top(input: Update) -> json.Json {
  let pairs = []
  let pairs = case input.condition_expression {
    option.Some(v) -> [#("ConditionExpression", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_names {
    option.Some(v) -> [
      #(
        "ExpressionAttributeNames",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_values {
    option.Some(v) -> [
      #(
        "ExpressionAttributeValues",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.key {
    option.Some(v) -> [
      #(
        "Key",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_values_on_condition_check_failure {
    option.Some(v) -> [
      #(
        "ReturnValuesOnConditionCheckFailure",
        encode_return_values_on_condition_check_failure_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.update_expression {
    option.Some(v) -> [#("UpdateExpression", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_struct() -> decode.Decoder(Update) {
  use <- decode.recursive
  use condition_expression <- decode.optional_field(
    "ConditionExpression",
    option.None,
    decode.optional(decode.string),
  )
  use expression_attribute_names <- decode.optional_field(
    "ExpressionAttributeNames",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use expression_attribute_values <- decode.optional_field(
    "ExpressionAttributeValues",
    option.None,
    decode.optional(decode.dict(decode.string, decode_attribute_value_union())),
  )
  use key <- decode.optional_field(
    "Key",
    option.None,
    decode.optional(decode.dict(decode.string, decode_attribute_value_union())),
  )
  use return_values_on_condition_check_failure <- decode.optional_field(
    "ReturnValuesOnConditionCheckFailure",
    option.None,
    decode.optional(decode_return_values_on_condition_check_failure_enum()),
  )
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  use update_expression <- decode.optional_field(
    "UpdateExpression",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(Update(
    condition_expression: condition_expression,
    expression_attribute_names: expression_attribute_names,
    expression_attribute_values: expression_attribute_values,
    key: key,
    return_values_on_condition_check_failure: return_values_on_condition_check_failure,
    table_name: table_name,
    update_expression: update_expression,
  ))
}

pub type TransactWriteItemsOutput {
  TransactWriteItemsOutput(
    consumed_capacity: option.Option(List(ConsumedCapacity)),
    item_collection_metrics: option.Option(
      dict.Dict(String, List(ItemCollectionMetrics)),
    ),
  )
}

pub fn transact_write_items_output_default() -> TransactWriteItemsOutput {
  TransactWriteItemsOutput(
    consumed_capacity: option.None,
    item_collection_metrics: option.None,
  )
}

pub fn encode_transact_write_items_output_struct(
  input: TransactWriteItemsOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.consumed_capacity {
    option.Some(v) -> [
      #(
        "ConsumedCapacity",
        fn(xs) { json.array(xs, encode_consumed_capacity_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.item_collection_metrics {
    option.Some(v) -> [
      #(
        "ItemCollectionMetrics",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(
                pair.0,
                fn(xs) { json.array(xs, encode_item_collection_metrics_struct) }(
                  pair.1,
                ),
              )
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_transact_write_items_output_struct_top(
  input: TransactWriteItemsOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.consumed_capacity {
    option.Some(v) -> [
      #(
        "ConsumedCapacity",
        fn(xs) { json.array(xs, encode_consumed_capacity_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.item_collection_metrics {
    option.Some(v) -> [
      #(
        "ItemCollectionMetrics",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(
                pair.0,
                fn(xs) { json.array(xs, encode_item_collection_metrics_struct) }(
                  pair.1,
                ),
              )
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_transact_write_items_output_struct() -> decode.Decoder(
  TransactWriteItemsOutput,
) {
  use <- decode.recursive
  use consumed_capacity <- decode.optional_field(
    "ConsumedCapacity",
    option.None,
    decode.optional(decode.list(decode_consumed_capacity_struct())),
  )
  use item_collection_metrics <- decode.optional_field(
    "ItemCollectionMetrics",
    option.None,
    decode.optional(decode.dict(
      decode.string,
      decode.list(decode_item_collection_metrics_struct()),
    )),
  )
  decode.success(TransactWriteItemsOutput(
    consumed_capacity: consumed_capacity,
    item_collection_metrics: item_collection_metrics,
  ))
}

pub type UntagResourceInput {
  UntagResourceInput(
    resource_arn: option.Option(String),
    tag_keys: option.Option(List(String)),
  )
}

pub fn untag_resource_input_default() -> UntagResourceInput {
  UntagResourceInput(resource_arn: option.None, tag_keys: option.None)
}

pub fn encode_untag_resource_input_struct(
  input: UntagResourceInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.resource_arn {
    option.Some(v) -> [#("ResourceArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.tag_keys {
    option.Some(v) -> [
      #("TagKeys", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_untag_resource_input_struct_top(
  input: UntagResourceInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.resource_arn {
    option.Some(v) -> [#("ResourceArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.tag_keys {
    option.Some(v) -> [
      #("TagKeys", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_untag_resource_input_struct() -> decode.Decoder(
  UntagResourceInput,
) {
  use <- decode.recursive
  use resource_arn <- decode.optional_field(
    "ResourceArn",
    option.None,
    decode.optional(decode.string),
  )
  use tag_keys <- decode.optional_field(
    "TagKeys",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  decode.success(UntagResourceInput(
    resource_arn: resource_arn,
    tag_keys: tag_keys,
  ))
}

pub type UpdateContinuousBackupsInput {
  UpdateContinuousBackupsInput(
    point_in_time_recovery_specification: option.Option(
      PointInTimeRecoverySpecification,
    ),
    table_name: option.Option(String),
  )
}

pub fn update_continuous_backups_input_default() -> UpdateContinuousBackupsInput {
  UpdateContinuousBackupsInput(
    point_in_time_recovery_specification: option.None,
    table_name: option.None,
  )
}

pub fn encode_update_continuous_backups_input_struct(
  input: UpdateContinuousBackupsInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.point_in_time_recovery_specification {
    option.Some(v) -> [
      #(
        "PointInTimeRecoverySpecification",
        encode_point_in_time_recovery_specification_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_update_continuous_backups_input_struct_top(
  input: UpdateContinuousBackupsInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.point_in_time_recovery_specification {
    option.Some(v) -> [
      #(
        "PointInTimeRecoverySpecification",
        encode_point_in_time_recovery_specification_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_continuous_backups_input_struct() -> decode.Decoder(
  UpdateContinuousBackupsInput,
) {
  use <- decode.recursive
  use point_in_time_recovery_specification <- decode.optional_field(
    "PointInTimeRecoverySpecification",
    option.None,
    decode.optional(decode_point_in_time_recovery_specification_struct()),
  )
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateContinuousBackupsInput(
    point_in_time_recovery_specification: point_in_time_recovery_specification,
    table_name: table_name,
  ))
}

pub type PointInTimeRecoverySpecification {
  PointInTimeRecoverySpecification(
    point_in_time_recovery_enabled: option.Option(Bool),
    recovery_period_in_days: option.Option(Int),
  )
}

pub fn point_in_time_recovery_specification_default() -> PointInTimeRecoverySpecification {
  PointInTimeRecoverySpecification(
    point_in_time_recovery_enabled: option.None,
    recovery_period_in_days: option.None,
  )
}

pub fn encode_point_in_time_recovery_specification_struct(
  input: PointInTimeRecoverySpecification,
) -> json.Json {
  let pairs = []
  let pairs = case input.point_in_time_recovery_enabled {
    option.Some(v) -> [#("PointInTimeRecoveryEnabled", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.recovery_period_in_days {
    option.Some(v) -> [#("RecoveryPeriodInDays", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_point_in_time_recovery_specification_struct_top(
  input: PointInTimeRecoverySpecification,
) -> json.Json {
  let pairs = []
  let pairs = case input.point_in_time_recovery_enabled {
    option.Some(v) -> [#("PointInTimeRecoveryEnabled", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.recovery_period_in_days {
    option.Some(v) -> [#("RecoveryPeriodInDays", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_point_in_time_recovery_specification_struct() -> decode.Decoder(
  PointInTimeRecoverySpecification,
) {
  use <- decode.recursive
  use point_in_time_recovery_enabled <- decode.optional_field(
    "PointInTimeRecoveryEnabled",
    option.None,
    decode.optional(decode.bool),
  )
  use recovery_period_in_days <- decode.optional_field(
    "RecoveryPeriodInDays",
    option.None,
    decode.optional(decode.int),
  )
  decode.success(PointInTimeRecoverySpecification(
    point_in_time_recovery_enabled: point_in_time_recovery_enabled,
    recovery_period_in_days: recovery_period_in_days,
  ))
}

pub type UpdateContinuousBackupsOutput {
  UpdateContinuousBackupsOutput(
    continuous_backups_description: option.Option(ContinuousBackupsDescription),
  )
}

pub fn update_continuous_backups_output_default() -> UpdateContinuousBackupsOutput {
  UpdateContinuousBackupsOutput(continuous_backups_description: option.None)
}

pub fn encode_update_continuous_backups_output_struct(
  input: UpdateContinuousBackupsOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.continuous_backups_description {
    option.Some(v) -> [
      #(
        "ContinuousBackupsDescription",
        encode_continuous_backups_description_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_update_continuous_backups_output_struct_top(
  input: UpdateContinuousBackupsOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.continuous_backups_description {
    option.Some(v) -> [
      #(
        "ContinuousBackupsDescription",
        encode_continuous_backups_description_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_continuous_backups_output_struct() -> decode.Decoder(
  UpdateContinuousBackupsOutput,
) {
  use <- decode.recursive
  use continuous_backups_description <- decode.optional_field(
    "ContinuousBackupsDescription",
    option.None,
    decode.optional(decode_continuous_backups_description_struct()),
  )
  decode.success(UpdateContinuousBackupsOutput(
    continuous_backups_description: continuous_backups_description,
  ))
}

pub type UpdateContributorInsightsInput {
  UpdateContributorInsightsInput(
    contributor_insights_action: option.Option(ContributorInsightsAction),
    contributor_insights_mode: option.Option(ContributorInsightsMode),
    index_name: option.Option(String),
    table_name: option.Option(String),
  )
}

pub fn update_contributor_insights_input_default() -> UpdateContributorInsightsInput {
  UpdateContributorInsightsInput(
    contributor_insights_action: option.None,
    contributor_insights_mode: option.None,
    index_name: option.None,
    table_name: option.None,
  )
}

pub fn encode_update_contributor_insights_input_struct(
  input: UpdateContributorInsightsInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.contributor_insights_action {
    option.Some(v) -> [
      #("ContributorInsightsAction", encode_contributor_insights_action_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.contributor_insights_mode {
    option.Some(v) -> [
      #("ContributorInsightsMode", encode_contributor_insights_mode_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_update_contributor_insights_input_struct_top(
  input: UpdateContributorInsightsInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.contributor_insights_action {
    option.Some(v) -> [
      #("ContributorInsightsAction", encode_contributor_insights_action_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.contributor_insights_mode {
    option.Some(v) -> [
      #("ContributorInsightsMode", encode_contributor_insights_mode_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_contributor_insights_input_struct() -> decode.Decoder(
  UpdateContributorInsightsInput,
) {
  use <- decode.recursive
  use contributor_insights_action <- decode.optional_field(
    "ContributorInsightsAction",
    option.None,
    decode.optional(decode_contributor_insights_action_enum()),
  )
  use contributor_insights_mode <- decode.optional_field(
    "ContributorInsightsMode",
    option.None,
    decode.optional(decode_contributor_insights_mode_enum()),
  )
  use index_name <- decode.optional_field(
    "IndexName",
    option.None,
    decode.optional(decode.string),
  )
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateContributorInsightsInput(
    contributor_insights_action: contributor_insights_action,
    contributor_insights_mode: contributor_insights_mode,
    index_name: index_name,
    table_name: table_name,
  ))
}

pub type ContributorInsightsAction {
  ContributorInsightsActionDisable
  ContributorInsightsActionEnable
}

pub fn encode_contributor_insights_action_enum(
  v: ContributorInsightsAction,
) -> json.Json {
  case v {
    ContributorInsightsActionDisable -> json.string("DISABLE")
    ContributorInsightsActionEnable -> json.string("ENABLE")
  }
}

pub fn decode_contributor_insights_action_enum() -> decode.Decoder(
  ContributorInsightsAction,
) {
  decode.then(decode.string, fn(s) {
    case s {
      "DISABLE" -> decode.success(ContributorInsightsActionDisable)
      "ENABLE" -> decode.success(ContributorInsightsActionEnable)
      _ ->
        decode.failure(ContributorInsightsActionDisable, "unknown enum value")
    }
  })
}

pub type UpdateContributorInsightsOutput {
  UpdateContributorInsightsOutput(
    contributor_insights_mode: option.Option(ContributorInsightsMode),
    contributor_insights_status: option.Option(ContributorInsightsStatus),
    index_name: option.Option(String),
    table_name: option.Option(String),
  )
}

pub fn update_contributor_insights_output_default() -> UpdateContributorInsightsOutput {
  UpdateContributorInsightsOutput(
    contributor_insights_mode: option.None,
    contributor_insights_status: option.None,
    index_name: option.None,
    table_name: option.None,
  )
}

pub fn encode_update_contributor_insights_output_struct(
  input: UpdateContributorInsightsOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.contributor_insights_mode {
    option.Some(v) -> [
      #("ContributorInsightsMode", encode_contributor_insights_mode_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.contributor_insights_status {
    option.Some(v) -> [
      #("ContributorInsightsStatus", encode_contributor_insights_status_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_update_contributor_insights_output_struct_top(
  input: UpdateContributorInsightsOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.contributor_insights_mode {
    option.Some(v) -> [
      #("ContributorInsightsMode", encode_contributor_insights_mode_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.contributor_insights_status {
    option.Some(v) -> [
      #("ContributorInsightsStatus", encode_contributor_insights_status_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_contributor_insights_output_struct() -> decode.Decoder(
  UpdateContributorInsightsOutput,
) {
  use <- decode.recursive
  use contributor_insights_mode <- decode.optional_field(
    "ContributorInsightsMode",
    option.None,
    decode.optional(decode_contributor_insights_mode_enum()),
  )
  use contributor_insights_status <- decode.optional_field(
    "ContributorInsightsStatus",
    option.None,
    decode.optional(decode_contributor_insights_status_enum()),
  )
  use index_name <- decode.optional_field(
    "IndexName",
    option.None,
    decode.optional(decode.string),
  )
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateContributorInsightsOutput(
    contributor_insights_mode: contributor_insights_mode,
    contributor_insights_status: contributor_insights_status,
    index_name: index_name,
    table_name: table_name,
  ))
}

pub type UpdateGlobalTableInput {
  UpdateGlobalTableInput(
    global_table_name: option.Option(String),
    replica_updates: option.Option(List(ReplicaUpdate)),
  )
}

pub fn update_global_table_input_default() -> UpdateGlobalTableInput {
  UpdateGlobalTableInput(
    global_table_name: option.None,
    replica_updates: option.None,
  )
}

pub fn encode_update_global_table_input_struct(
  input: UpdateGlobalTableInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.global_table_name {
    option.Some(v) -> [#("GlobalTableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.replica_updates {
    option.Some(v) -> [
      #(
        "ReplicaUpdates",
        fn(xs) { json.array(xs, encode_replica_update_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_update_global_table_input_struct_top(
  input: UpdateGlobalTableInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.global_table_name {
    option.Some(v) -> [#("GlobalTableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.replica_updates {
    option.Some(v) -> [
      #(
        "ReplicaUpdates",
        fn(xs) { json.array(xs, encode_replica_update_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_global_table_input_struct() -> decode.Decoder(
  UpdateGlobalTableInput,
) {
  use <- decode.recursive
  use global_table_name <- decode.optional_field(
    "GlobalTableName",
    option.None,
    decode.optional(decode.string),
  )
  use replica_updates <- decode.optional_field(
    "ReplicaUpdates",
    option.None,
    decode.optional(decode.list(decode_replica_update_struct())),
  )
  decode.success(UpdateGlobalTableInput(
    global_table_name: global_table_name,
    replica_updates: replica_updates,
  ))
}

pub type ReplicaUpdate {
  ReplicaUpdate(
    create: option.Option(CreateReplicaAction),
    delete: option.Option(DeleteReplicaAction),
  )
}

pub fn replica_update_default() -> ReplicaUpdate {
  ReplicaUpdate(create: option.None, delete: option.None)
}

pub fn encode_replica_update_struct(input: ReplicaUpdate) -> json.Json {
  let pairs = []
  let pairs = case input.create {
    option.Some(v) -> [
      #("Create", encode_create_replica_action_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.delete {
    option.Some(v) -> [
      #("Delete", encode_delete_replica_action_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_replica_update_struct_top(input: ReplicaUpdate) -> json.Json {
  let pairs = []
  let pairs = case input.create {
    option.Some(v) -> [
      #("Create", encode_create_replica_action_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.delete {
    option.Some(v) -> [
      #("Delete", encode_delete_replica_action_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_replica_update_struct() -> decode.Decoder(ReplicaUpdate) {
  use <- decode.recursive
  use create <- decode.optional_field(
    "Create",
    option.None,
    decode.optional(decode_create_replica_action_struct()),
  )
  use delete <- decode.optional_field(
    "Delete",
    option.None,
    decode.optional(decode_delete_replica_action_struct()),
  )
  decode.success(ReplicaUpdate(create: create, delete: delete))
}

pub type CreateReplicaAction {
  CreateReplicaAction(region_name: option.Option(String))
}

pub fn create_replica_action_default() -> CreateReplicaAction {
  CreateReplicaAction(region_name: option.None)
}

pub fn encode_create_replica_action_struct(
  input: CreateReplicaAction,
) -> json.Json {
  let pairs = []
  let pairs = case input.region_name {
    option.Some(v) -> [#("RegionName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_create_replica_action_struct_top(
  input: CreateReplicaAction,
) -> json.Json {
  let pairs = []
  let pairs = case input.region_name {
    option.Some(v) -> [#("RegionName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_create_replica_action_struct() -> decode.Decoder(
  CreateReplicaAction,
) {
  use <- decode.recursive
  use region_name <- decode.optional_field(
    "RegionName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(CreateReplicaAction(region_name: region_name))
}

pub type DeleteReplicaAction {
  DeleteReplicaAction(region_name: option.Option(String))
}

pub fn delete_replica_action_default() -> DeleteReplicaAction {
  DeleteReplicaAction(region_name: option.None)
}

pub fn encode_delete_replica_action_struct(
  input: DeleteReplicaAction,
) -> json.Json {
  let pairs = []
  let pairs = case input.region_name {
    option.Some(v) -> [#("RegionName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_delete_replica_action_struct_top(
  input: DeleteReplicaAction,
) -> json.Json {
  let pairs = []
  let pairs = case input.region_name {
    option.Some(v) -> [#("RegionName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_delete_replica_action_struct() -> decode.Decoder(
  DeleteReplicaAction,
) {
  use <- decode.recursive
  use region_name <- decode.optional_field(
    "RegionName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteReplicaAction(region_name: region_name))
}

pub type UpdateGlobalTableOutput {
  UpdateGlobalTableOutput(
    global_table_description: option.Option(GlobalTableDescription),
  )
}

pub fn update_global_table_output_default() -> UpdateGlobalTableOutput {
  UpdateGlobalTableOutput(global_table_description: option.None)
}

pub fn encode_update_global_table_output_struct(
  input: UpdateGlobalTableOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.global_table_description {
    option.Some(v) -> [
      #("GlobalTableDescription", encode_global_table_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_update_global_table_output_struct_top(
  input: UpdateGlobalTableOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.global_table_description {
    option.Some(v) -> [
      #("GlobalTableDescription", encode_global_table_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_global_table_output_struct() -> decode.Decoder(
  UpdateGlobalTableOutput,
) {
  use <- decode.recursive
  use global_table_description <- decode.optional_field(
    "GlobalTableDescription",
    option.None,
    decode.optional(decode_global_table_description_struct()),
  )
  decode.success(UpdateGlobalTableOutput(
    global_table_description: global_table_description,
  ))
}

pub type ReplicaAlreadyExistsException {
  ReplicaAlreadyExistsException(message: option.Option(String))
}

pub fn replica_already_exists_exception_default() -> ReplicaAlreadyExistsException {
  ReplicaAlreadyExistsException(message: option.None)
}

pub fn encode_replica_already_exists_exception_struct(
  input: ReplicaAlreadyExistsException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_replica_already_exists_exception_struct_top(
  input: ReplicaAlreadyExistsException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_replica_already_exists_exception_struct() -> decode.Decoder(
  ReplicaAlreadyExistsException,
) {
  use <- decode.recursive
  use message <- decode.optional_field(
    "message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ReplicaAlreadyExistsException(message: message))
}

pub type ReplicaNotFoundException {
  ReplicaNotFoundException(message: option.Option(String))
}

pub fn replica_not_found_exception_default() -> ReplicaNotFoundException {
  ReplicaNotFoundException(message: option.None)
}

pub fn encode_replica_not_found_exception_struct(
  input: ReplicaNotFoundException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_replica_not_found_exception_struct_top(
  input: ReplicaNotFoundException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_replica_not_found_exception_struct() -> decode.Decoder(
  ReplicaNotFoundException,
) {
  use <- decode.recursive
  use message <- decode.optional_field(
    "message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ReplicaNotFoundException(message: message))
}

pub type UpdateGlobalTableSettingsInput {
  UpdateGlobalTableSettingsInput(
    global_table_billing_mode: option.Option(BillingMode),
    global_table_global_secondary_index_settings_update: option.Option(
      List(GlobalTableGlobalSecondaryIndexSettingsUpdate),
    ),
    global_table_name: option.Option(String),
    global_table_provisioned_write_capacity_auto_scaling_settings_update: option.Option(
      AutoScalingSettingsUpdate,
    ),
    global_table_provisioned_write_capacity_units: option.Option(Int),
    replica_settings_update: option.Option(List(ReplicaSettingsUpdate)),
  )
}

pub fn update_global_table_settings_input_default() -> UpdateGlobalTableSettingsInput {
  UpdateGlobalTableSettingsInput(
    global_table_billing_mode: option.None,
    global_table_global_secondary_index_settings_update: option.None,
    global_table_name: option.None,
    global_table_provisioned_write_capacity_auto_scaling_settings_update: option.None,
    global_table_provisioned_write_capacity_units: option.None,
    replica_settings_update: option.None,
  )
}

pub fn encode_update_global_table_settings_input_struct(
  input: UpdateGlobalTableSettingsInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.global_table_billing_mode {
    option.Some(v) -> [
      #("GlobalTableBillingMode", encode_billing_mode_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.global_table_global_secondary_index_settings_update {
    option.Some(v) -> [
      #(
        "GlobalTableGlobalSecondaryIndexSettingsUpdate",
        fn(xs) {
          json.array(
            xs,
            encode_global_table_global_secondary_index_settings_update_struct,
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.global_table_name {
    option.Some(v) -> [#("GlobalTableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case
    input.global_table_provisioned_write_capacity_auto_scaling_settings_update
  {
    option.Some(v) -> [
      #(
        "GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate",
        encode_auto_scaling_settings_update_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.global_table_provisioned_write_capacity_units {
    option.Some(v) -> [
      #("GlobalTableProvisionedWriteCapacityUnits", json.int(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.replica_settings_update {
    option.Some(v) -> [
      #(
        "ReplicaSettingsUpdate",
        fn(xs) { json.array(xs, encode_replica_settings_update_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_update_global_table_settings_input_struct_top(
  input: UpdateGlobalTableSettingsInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.global_table_billing_mode {
    option.Some(v) -> [
      #("GlobalTableBillingMode", encode_billing_mode_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.global_table_global_secondary_index_settings_update {
    option.Some(v) -> [
      #(
        "GlobalTableGlobalSecondaryIndexSettingsUpdate",
        fn(xs) {
          json.array(
            xs,
            encode_global_table_global_secondary_index_settings_update_struct,
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.global_table_name {
    option.Some(v) -> [#("GlobalTableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case
    input.global_table_provisioned_write_capacity_auto_scaling_settings_update
  {
    option.Some(v) -> [
      #(
        "GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate",
        encode_auto_scaling_settings_update_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.global_table_provisioned_write_capacity_units {
    option.Some(v) -> [
      #("GlobalTableProvisionedWriteCapacityUnits", json.int(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.replica_settings_update {
    option.Some(v) -> [
      #(
        "ReplicaSettingsUpdate",
        fn(xs) { json.array(xs, encode_replica_settings_update_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_global_table_settings_input_struct() -> decode.Decoder(
  UpdateGlobalTableSettingsInput,
) {
  use <- decode.recursive
  use global_table_billing_mode <- decode.optional_field(
    "GlobalTableBillingMode",
    option.None,
    decode.optional(decode_billing_mode_enum()),
  )
  use global_table_global_secondary_index_settings_update <- decode.optional_field(
    "GlobalTableGlobalSecondaryIndexSettingsUpdate",
    option.None,
    decode.optional(
      decode.list(
        decode_global_table_global_secondary_index_settings_update_struct(),
      ),
    ),
  )
  use global_table_name <- decode.optional_field(
    "GlobalTableName",
    option.None,
    decode.optional(decode.string),
  )
  use global_table_provisioned_write_capacity_auto_scaling_settings_update <- decode.optional_field(
    "GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate",
    option.None,
    decode.optional(decode_auto_scaling_settings_update_struct()),
  )
  use global_table_provisioned_write_capacity_units <- decode.optional_field(
    "GlobalTableProvisionedWriteCapacityUnits",
    option.None,
    decode.optional(decode.int),
  )
  use replica_settings_update <- decode.optional_field(
    "ReplicaSettingsUpdate",
    option.None,
    decode.optional(decode.list(decode_replica_settings_update_struct())),
  )
  decode.success(UpdateGlobalTableSettingsInput(
    global_table_billing_mode: global_table_billing_mode,
    global_table_global_secondary_index_settings_update: global_table_global_secondary_index_settings_update,
    global_table_name: global_table_name,
    global_table_provisioned_write_capacity_auto_scaling_settings_update: global_table_provisioned_write_capacity_auto_scaling_settings_update,
    global_table_provisioned_write_capacity_units: global_table_provisioned_write_capacity_units,
    replica_settings_update: replica_settings_update,
  ))
}

pub type GlobalTableGlobalSecondaryIndexSettingsUpdate {
  GlobalTableGlobalSecondaryIndexSettingsUpdate(
    index_name: option.Option(String),
    provisioned_write_capacity_auto_scaling_settings_update: option.Option(
      AutoScalingSettingsUpdate,
    ),
    provisioned_write_capacity_units: option.Option(Int),
  )
}

pub fn global_table_global_secondary_index_settings_update_default() -> GlobalTableGlobalSecondaryIndexSettingsUpdate {
  GlobalTableGlobalSecondaryIndexSettingsUpdate(
    index_name: option.None,
    provisioned_write_capacity_auto_scaling_settings_update: option.None,
    provisioned_write_capacity_units: option.None,
  )
}

pub fn encode_global_table_global_secondary_index_settings_update_struct(
  input: GlobalTableGlobalSecondaryIndexSettingsUpdate,
) -> json.Json {
  let pairs = []
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case
    input.provisioned_write_capacity_auto_scaling_settings_update
  {
    option.Some(v) -> [
      #(
        "ProvisionedWriteCapacityAutoScalingSettingsUpdate",
        encode_auto_scaling_settings_update_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_write_capacity_units {
    option.Some(v) -> [#("ProvisionedWriteCapacityUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_global_table_global_secondary_index_settings_update_struct_top(
  input: GlobalTableGlobalSecondaryIndexSettingsUpdate,
) -> json.Json {
  let pairs = []
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case
    input.provisioned_write_capacity_auto_scaling_settings_update
  {
    option.Some(v) -> [
      #(
        "ProvisionedWriteCapacityAutoScalingSettingsUpdate",
        encode_auto_scaling_settings_update_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_write_capacity_units {
    option.Some(v) -> [#("ProvisionedWriteCapacityUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_global_table_global_secondary_index_settings_update_struct() -> decode.Decoder(
  GlobalTableGlobalSecondaryIndexSettingsUpdate,
) {
  use <- decode.recursive
  use index_name <- decode.optional_field(
    "IndexName",
    option.None,
    decode.optional(decode.string),
  )
  use provisioned_write_capacity_auto_scaling_settings_update <- decode.optional_field(
    "ProvisionedWriteCapacityAutoScalingSettingsUpdate",
    option.None,
    decode.optional(decode_auto_scaling_settings_update_struct()),
  )
  use provisioned_write_capacity_units <- decode.optional_field(
    "ProvisionedWriteCapacityUnits",
    option.None,
    decode.optional(decode.int),
  )
  decode.success(GlobalTableGlobalSecondaryIndexSettingsUpdate(
    index_name: index_name,
    provisioned_write_capacity_auto_scaling_settings_update: provisioned_write_capacity_auto_scaling_settings_update,
    provisioned_write_capacity_units: provisioned_write_capacity_units,
  ))
}

pub type AutoScalingSettingsUpdate {
  AutoScalingSettingsUpdate(
    auto_scaling_disabled: option.Option(Bool),
    auto_scaling_role_arn: option.Option(String),
    maximum_units: option.Option(Int),
    minimum_units: option.Option(Int),
    scaling_policy_update: option.Option(AutoScalingPolicyUpdate),
  )
}

pub fn auto_scaling_settings_update_default() -> AutoScalingSettingsUpdate {
  AutoScalingSettingsUpdate(
    auto_scaling_disabled: option.None,
    auto_scaling_role_arn: option.None,
    maximum_units: option.None,
    minimum_units: option.None,
    scaling_policy_update: option.None,
  )
}

pub fn encode_auto_scaling_settings_update_struct(
  input: AutoScalingSettingsUpdate,
) -> json.Json {
  let pairs = []
  let pairs = case input.auto_scaling_disabled {
    option.Some(v) -> [#("AutoScalingDisabled", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.auto_scaling_role_arn {
    option.Some(v) -> [#("AutoScalingRoleArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.maximum_units {
    option.Some(v) -> [#("MaximumUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.minimum_units {
    option.Some(v) -> [#("MinimumUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.scaling_policy_update {
    option.Some(v) -> [
      #("ScalingPolicyUpdate", encode_auto_scaling_policy_update_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_auto_scaling_settings_update_struct_top(
  input: AutoScalingSettingsUpdate,
) -> json.Json {
  let pairs = []
  let pairs = case input.auto_scaling_disabled {
    option.Some(v) -> [#("AutoScalingDisabled", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.auto_scaling_role_arn {
    option.Some(v) -> [#("AutoScalingRoleArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.maximum_units {
    option.Some(v) -> [#("MaximumUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.minimum_units {
    option.Some(v) -> [#("MinimumUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.scaling_policy_update {
    option.Some(v) -> [
      #("ScalingPolicyUpdate", encode_auto_scaling_policy_update_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_auto_scaling_settings_update_struct() -> decode.Decoder(
  AutoScalingSettingsUpdate,
) {
  use <- decode.recursive
  use auto_scaling_disabled <- decode.optional_field(
    "AutoScalingDisabled",
    option.None,
    decode.optional(decode.bool),
  )
  use auto_scaling_role_arn <- decode.optional_field(
    "AutoScalingRoleArn",
    option.None,
    decode.optional(decode.string),
  )
  use maximum_units <- decode.optional_field(
    "MaximumUnits",
    option.None,
    decode.optional(decode.int),
  )
  use minimum_units <- decode.optional_field(
    "MinimumUnits",
    option.None,
    decode.optional(decode.int),
  )
  use scaling_policy_update <- decode.optional_field(
    "ScalingPolicyUpdate",
    option.None,
    decode.optional(decode_auto_scaling_policy_update_struct()),
  )
  decode.success(AutoScalingSettingsUpdate(
    auto_scaling_disabled: auto_scaling_disabled,
    auto_scaling_role_arn: auto_scaling_role_arn,
    maximum_units: maximum_units,
    minimum_units: minimum_units,
    scaling_policy_update: scaling_policy_update,
  ))
}

pub type AutoScalingPolicyUpdate {
  AutoScalingPolicyUpdate(
    policy_name: option.Option(String),
    target_tracking_scaling_policy_configuration: option.Option(
      AutoScalingTargetTrackingScalingPolicyConfigurationUpdate,
    ),
  )
}

pub fn auto_scaling_policy_update_default() -> AutoScalingPolicyUpdate {
  AutoScalingPolicyUpdate(
    policy_name: option.None,
    target_tracking_scaling_policy_configuration: option.None,
  )
}

pub fn encode_auto_scaling_policy_update_struct(
  input: AutoScalingPolicyUpdate,
) -> json.Json {
  let pairs = []
  let pairs = case input.policy_name {
    option.Some(v) -> [#("PolicyName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.target_tracking_scaling_policy_configuration {
    option.Some(v) -> [
      #(
        "TargetTrackingScalingPolicyConfiguration",
        encode_auto_scaling_target_tracking_scaling_policy_configuration_update_struct(
          v,
        ),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_auto_scaling_policy_update_struct_top(
  input: AutoScalingPolicyUpdate,
) -> json.Json {
  let pairs = []
  let pairs = case input.policy_name {
    option.Some(v) -> [#("PolicyName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.target_tracking_scaling_policy_configuration {
    option.Some(v) -> [
      #(
        "TargetTrackingScalingPolicyConfiguration",
        encode_auto_scaling_target_tracking_scaling_policy_configuration_update_struct(
          v,
        ),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_auto_scaling_policy_update_struct() -> decode.Decoder(
  AutoScalingPolicyUpdate,
) {
  use <- decode.recursive
  use policy_name <- decode.optional_field(
    "PolicyName",
    option.None,
    decode.optional(decode.string),
  )
  use target_tracking_scaling_policy_configuration <- decode.optional_field(
    "TargetTrackingScalingPolicyConfiguration",
    option.None,
    decode.optional(
      decode_auto_scaling_target_tracking_scaling_policy_configuration_update_struct(),
    ),
  )
  decode.success(AutoScalingPolicyUpdate(
    policy_name: policy_name,
    target_tracking_scaling_policy_configuration: target_tracking_scaling_policy_configuration,
  ))
}

pub type AutoScalingTargetTrackingScalingPolicyConfigurationUpdate {
  AutoScalingTargetTrackingScalingPolicyConfigurationUpdate(
    disable_scale_in: option.Option(Bool),
    scale_in_cooldown: option.Option(Int),
    scale_out_cooldown: option.Option(Int),
    target_value: option.Option(json_float.SmithyFloat),
  )
}

pub fn auto_scaling_target_tracking_scaling_policy_configuration_update_default() -> AutoScalingTargetTrackingScalingPolicyConfigurationUpdate {
  AutoScalingTargetTrackingScalingPolicyConfigurationUpdate(
    disable_scale_in: option.None,
    scale_in_cooldown: option.None,
    scale_out_cooldown: option.None,
    target_value: option.None,
  )
}

pub fn encode_auto_scaling_target_tracking_scaling_policy_configuration_update_struct(
  input: AutoScalingTargetTrackingScalingPolicyConfigurationUpdate,
) -> json.Json {
  let pairs = []
  let pairs = case input.disable_scale_in {
    option.Some(v) -> [#("DisableScaleIn", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.scale_in_cooldown {
    option.Some(v) -> [#("ScaleInCooldown", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.scale_out_cooldown {
    option.Some(v) -> [#("ScaleOutCooldown", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.target_value {
    option.Some(v) -> [#("TargetValue", json_float.encode(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_auto_scaling_target_tracking_scaling_policy_configuration_update_struct_top(
  input: AutoScalingTargetTrackingScalingPolicyConfigurationUpdate,
) -> json.Json {
  let pairs = []
  let pairs = case input.disable_scale_in {
    option.Some(v) -> [#("DisableScaleIn", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.scale_in_cooldown {
    option.Some(v) -> [#("ScaleInCooldown", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.scale_out_cooldown {
    option.Some(v) -> [#("ScaleOutCooldown", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.target_value {
    option.Some(v) -> [#("TargetValue", json_float.encode(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_auto_scaling_target_tracking_scaling_policy_configuration_update_struct() -> decode.Decoder(
  AutoScalingTargetTrackingScalingPolicyConfigurationUpdate,
) {
  use <- decode.recursive
  use disable_scale_in <- decode.optional_field(
    "DisableScaleIn",
    option.None,
    decode.optional(decode.bool),
  )
  use scale_in_cooldown <- decode.optional_field(
    "ScaleInCooldown",
    option.None,
    decode.optional(decode.int),
  )
  use scale_out_cooldown <- decode.optional_field(
    "ScaleOutCooldown",
    option.None,
    decode.optional(decode.int),
  )
  use target_value <- decode.optional_field(
    "TargetValue",
    option.None,
    decode.optional(json_float.decoder()),
  )
  decode.success(AutoScalingTargetTrackingScalingPolicyConfigurationUpdate(
    disable_scale_in: disable_scale_in,
    scale_in_cooldown: scale_in_cooldown,
    scale_out_cooldown: scale_out_cooldown,
    target_value: target_value,
  ))
}

pub type ReplicaSettingsUpdate {
  ReplicaSettingsUpdate(
    region_name: option.Option(String),
    replica_global_secondary_index_settings_update: option.Option(
      List(ReplicaGlobalSecondaryIndexSettingsUpdate),
    ),
    replica_provisioned_read_capacity_auto_scaling_settings_update: option.Option(
      AutoScalingSettingsUpdate,
    ),
    replica_provisioned_read_capacity_units: option.Option(Int),
    replica_table_class: option.Option(TableClass),
  )
}

pub fn replica_settings_update_default() -> ReplicaSettingsUpdate {
  ReplicaSettingsUpdate(
    region_name: option.None,
    replica_global_secondary_index_settings_update: option.None,
    replica_provisioned_read_capacity_auto_scaling_settings_update: option.None,
    replica_provisioned_read_capacity_units: option.None,
    replica_table_class: option.None,
  )
}

pub fn encode_replica_settings_update_struct(
  input: ReplicaSettingsUpdate,
) -> json.Json {
  let pairs = []
  let pairs = case input.region_name {
    option.Some(v) -> [#("RegionName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.replica_global_secondary_index_settings_update {
    option.Some(v) -> [
      #(
        "ReplicaGlobalSecondaryIndexSettingsUpdate",
        fn(xs) {
          json.array(
            xs,
            encode_replica_global_secondary_index_settings_update_struct,
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case
    input.replica_provisioned_read_capacity_auto_scaling_settings_update
  {
    option.Some(v) -> [
      #(
        "ReplicaProvisionedReadCapacityAutoScalingSettingsUpdate",
        encode_auto_scaling_settings_update_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.replica_provisioned_read_capacity_units {
    option.Some(v) -> [
      #("ReplicaProvisionedReadCapacityUnits", json.int(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.replica_table_class {
    option.Some(v) -> [
      #("ReplicaTableClass", encode_table_class_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_replica_settings_update_struct_top(
  input: ReplicaSettingsUpdate,
) -> json.Json {
  let pairs = []
  let pairs = case input.region_name {
    option.Some(v) -> [#("RegionName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.replica_global_secondary_index_settings_update {
    option.Some(v) -> [
      #(
        "ReplicaGlobalSecondaryIndexSettingsUpdate",
        fn(xs) {
          json.array(
            xs,
            encode_replica_global_secondary_index_settings_update_struct,
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case
    input.replica_provisioned_read_capacity_auto_scaling_settings_update
  {
    option.Some(v) -> [
      #(
        "ReplicaProvisionedReadCapacityAutoScalingSettingsUpdate",
        encode_auto_scaling_settings_update_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.replica_provisioned_read_capacity_units {
    option.Some(v) -> [
      #("ReplicaProvisionedReadCapacityUnits", json.int(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.replica_table_class {
    option.Some(v) -> [
      #("ReplicaTableClass", encode_table_class_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_replica_settings_update_struct() -> decode.Decoder(
  ReplicaSettingsUpdate,
) {
  use <- decode.recursive
  use region_name <- decode.optional_field(
    "RegionName",
    option.None,
    decode.optional(decode.string),
  )
  use replica_global_secondary_index_settings_update <- decode.optional_field(
    "ReplicaGlobalSecondaryIndexSettingsUpdate",
    option.None,
    decode.optional(
      decode.list(
        decode_replica_global_secondary_index_settings_update_struct(),
      ),
    ),
  )
  use replica_provisioned_read_capacity_auto_scaling_settings_update <- decode.optional_field(
    "ReplicaProvisionedReadCapacityAutoScalingSettingsUpdate",
    option.None,
    decode.optional(decode_auto_scaling_settings_update_struct()),
  )
  use replica_provisioned_read_capacity_units <- decode.optional_field(
    "ReplicaProvisionedReadCapacityUnits",
    option.None,
    decode.optional(decode.int),
  )
  use replica_table_class <- decode.optional_field(
    "ReplicaTableClass",
    option.None,
    decode.optional(decode_table_class_enum()),
  )
  decode.success(ReplicaSettingsUpdate(
    region_name: region_name,
    replica_global_secondary_index_settings_update: replica_global_secondary_index_settings_update,
    replica_provisioned_read_capacity_auto_scaling_settings_update: replica_provisioned_read_capacity_auto_scaling_settings_update,
    replica_provisioned_read_capacity_units: replica_provisioned_read_capacity_units,
    replica_table_class: replica_table_class,
  ))
}

pub type ReplicaGlobalSecondaryIndexSettingsUpdate {
  ReplicaGlobalSecondaryIndexSettingsUpdate(
    index_name: option.Option(String),
    provisioned_read_capacity_auto_scaling_settings_update: option.Option(
      AutoScalingSettingsUpdate,
    ),
    provisioned_read_capacity_units: option.Option(Int),
  )
}

pub fn replica_global_secondary_index_settings_update_default() -> ReplicaGlobalSecondaryIndexSettingsUpdate {
  ReplicaGlobalSecondaryIndexSettingsUpdate(
    index_name: option.None,
    provisioned_read_capacity_auto_scaling_settings_update: option.None,
    provisioned_read_capacity_units: option.None,
  )
}

pub fn encode_replica_global_secondary_index_settings_update_struct(
  input: ReplicaGlobalSecondaryIndexSettingsUpdate,
) -> json.Json {
  let pairs = []
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case
    input.provisioned_read_capacity_auto_scaling_settings_update
  {
    option.Some(v) -> [
      #(
        "ProvisionedReadCapacityAutoScalingSettingsUpdate",
        encode_auto_scaling_settings_update_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_read_capacity_units {
    option.Some(v) -> [#("ProvisionedReadCapacityUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_replica_global_secondary_index_settings_update_struct_top(
  input: ReplicaGlobalSecondaryIndexSettingsUpdate,
) -> json.Json {
  let pairs = []
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case
    input.provisioned_read_capacity_auto_scaling_settings_update
  {
    option.Some(v) -> [
      #(
        "ProvisionedReadCapacityAutoScalingSettingsUpdate",
        encode_auto_scaling_settings_update_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_read_capacity_units {
    option.Some(v) -> [#("ProvisionedReadCapacityUnits", json.int(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_replica_global_secondary_index_settings_update_struct() -> decode.Decoder(
  ReplicaGlobalSecondaryIndexSettingsUpdate,
) {
  use <- decode.recursive
  use index_name <- decode.optional_field(
    "IndexName",
    option.None,
    decode.optional(decode.string),
  )
  use provisioned_read_capacity_auto_scaling_settings_update <- decode.optional_field(
    "ProvisionedReadCapacityAutoScalingSettingsUpdate",
    option.None,
    decode.optional(decode_auto_scaling_settings_update_struct()),
  )
  use provisioned_read_capacity_units <- decode.optional_field(
    "ProvisionedReadCapacityUnits",
    option.None,
    decode.optional(decode.int),
  )
  decode.success(ReplicaGlobalSecondaryIndexSettingsUpdate(
    index_name: index_name,
    provisioned_read_capacity_auto_scaling_settings_update: provisioned_read_capacity_auto_scaling_settings_update,
    provisioned_read_capacity_units: provisioned_read_capacity_units,
  ))
}

pub type UpdateGlobalTableSettingsOutput {
  UpdateGlobalTableSettingsOutput(
    global_table_name: option.Option(String),
    replica_settings: option.Option(List(ReplicaSettingsDescription)),
  )
}

pub fn update_global_table_settings_output_default() -> UpdateGlobalTableSettingsOutput {
  UpdateGlobalTableSettingsOutput(
    global_table_name: option.None,
    replica_settings: option.None,
  )
}

pub fn encode_update_global_table_settings_output_struct(
  input: UpdateGlobalTableSettingsOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.global_table_name {
    option.Some(v) -> [#("GlobalTableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.replica_settings {
    option.Some(v) -> [
      #(
        "ReplicaSettings",
        fn(xs) { json.array(xs, encode_replica_settings_description_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_update_global_table_settings_output_struct_top(
  input: UpdateGlobalTableSettingsOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.global_table_name {
    option.Some(v) -> [#("GlobalTableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.replica_settings {
    option.Some(v) -> [
      #(
        "ReplicaSettings",
        fn(xs) { json.array(xs, encode_replica_settings_description_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_global_table_settings_output_struct() -> decode.Decoder(
  UpdateGlobalTableSettingsOutput,
) {
  use <- decode.recursive
  use global_table_name <- decode.optional_field(
    "GlobalTableName",
    option.None,
    decode.optional(decode.string),
  )
  use replica_settings <- decode.optional_field(
    "ReplicaSettings",
    option.None,
    decode.optional(decode.list(decode_replica_settings_description_struct())),
  )
  decode.success(UpdateGlobalTableSettingsOutput(
    global_table_name: global_table_name,
    replica_settings: replica_settings,
  ))
}

pub type IndexNotFoundException {
  IndexNotFoundException(message: option.Option(String))
}

pub fn index_not_found_exception_default() -> IndexNotFoundException {
  IndexNotFoundException(message: option.None)
}

pub fn encode_index_not_found_exception_struct(
  input: IndexNotFoundException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_index_not_found_exception_struct_top(
  input: IndexNotFoundException,
) -> json.Json {
  let pairs = []
  let pairs = case input.message {
    option.Some(v) -> [#("message", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_index_not_found_exception_struct() -> decode.Decoder(
  IndexNotFoundException,
) {
  use <- decode.recursive
  use message <- decode.optional_field(
    "message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(IndexNotFoundException(message: message))
}

pub type UpdateItemInput {
  UpdateItemInput(
    attribute_updates: option.Option(dict.Dict(String, AttributeValueUpdate)),
    condition_expression: option.Option(String),
    conditional_operator: option.Option(ConditionalOperator),
    expected: option.Option(dict.Dict(String, ExpectedAttributeValue)),
    expression_attribute_names: option.Option(dict.Dict(String, String)),
    expression_attribute_values: option.Option(
      dict.Dict(String, AttributeValue),
    ),
    key: option.Option(dict.Dict(String, AttributeValue)),
    return_consumed_capacity: option.Option(ReturnConsumedCapacity),
    return_item_collection_metrics: option.Option(ReturnItemCollectionMetrics),
    return_values: option.Option(ReturnValue),
    return_values_on_condition_check_failure: option.Option(
      ReturnValuesOnConditionCheckFailure,
    ),
    table_name: option.Option(String),
    update_expression: option.Option(String),
  )
}

pub fn update_item_input_default() -> UpdateItemInput {
  UpdateItemInput(
    attribute_updates: option.None,
    condition_expression: option.None,
    conditional_operator: option.None,
    expected: option.None,
    expression_attribute_names: option.None,
    expression_attribute_values: option.None,
    key: option.None,
    return_consumed_capacity: option.None,
    return_item_collection_metrics: option.None,
    return_values: option.None,
    return_values_on_condition_check_failure: option.None,
    table_name: option.None,
    update_expression: option.None,
  )
}

pub fn encode_update_item_input_struct(input: UpdateItemInput) -> json.Json {
  let pairs = []
  let pairs = case input.attribute_updates {
    option.Some(v) -> [
      #(
        "AttributeUpdates",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_update_struct(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.condition_expression {
    option.Some(v) -> [#("ConditionExpression", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.conditional_operator {
    option.Some(v) -> [
      #("ConditionalOperator", encode_conditional_operator_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.expected {
    option.Some(v) -> [
      #(
        "Expected",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_expected_attribute_value_struct(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_names {
    option.Some(v) -> [
      #(
        "ExpressionAttributeNames",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_values {
    option.Some(v) -> [
      #(
        "ExpressionAttributeValues",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.key {
    option.Some(v) -> [
      #(
        "Key",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_consumed_capacity {
    option.Some(v) -> [
      #("ReturnConsumedCapacity", encode_return_consumed_capacity_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_item_collection_metrics {
    option.Some(v) -> [
      #(
        "ReturnItemCollectionMetrics",
        encode_return_item_collection_metrics_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_values {
    option.Some(v) -> [#("ReturnValues", encode_return_value_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.return_values_on_condition_check_failure {
    option.Some(v) -> [
      #(
        "ReturnValuesOnConditionCheckFailure",
        encode_return_values_on_condition_check_failure_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.update_expression {
    option.Some(v) -> [#("UpdateExpression", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_update_item_input_struct_top(
  input: UpdateItemInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.attribute_updates {
    option.Some(v) -> [
      #(
        "AttributeUpdates",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_update_struct(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.condition_expression {
    option.Some(v) -> [#("ConditionExpression", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.conditional_operator {
    option.Some(v) -> [
      #("ConditionalOperator", encode_conditional_operator_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.expected {
    option.Some(v) -> [
      #(
        "Expected",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_expected_attribute_value_struct(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_names {
    option.Some(v) -> [
      #(
        "ExpressionAttributeNames",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.expression_attribute_values {
    option.Some(v) -> [
      #(
        "ExpressionAttributeValues",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.key {
    option.Some(v) -> [
      #(
        "Key",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_consumed_capacity {
    option.Some(v) -> [
      #("ReturnConsumedCapacity", encode_return_consumed_capacity_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_item_collection_metrics {
    option.Some(v) -> [
      #(
        "ReturnItemCollectionMetrics",
        encode_return_item_collection_metrics_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.return_values {
    option.Some(v) -> [#("ReturnValues", encode_return_value_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.return_values_on_condition_check_failure {
    option.Some(v) -> [
      #(
        "ReturnValuesOnConditionCheckFailure",
        encode_return_values_on_condition_check_failure_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.update_expression {
    option.Some(v) -> [#("UpdateExpression", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_item_input_struct() -> decode.Decoder(UpdateItemInput) {
  use <- decode.recursive
  use attribute_updates <- decode.optional_field(
    "AttributeUpdates",
    option.None,
    decode.optional(decode.dict(
      decode.string,
      decode_attribute_value_update_struct(),
    )),
  )
  use condition_expression <- decode.optional_field(
    "ConditionExpression",
    option.None,
    decode.optional(decode.string),
  )
  use conditional_operator <- decode.optional_field(
    "ConditionalOperator",
    option.None,
    decode.optional(decode_conditional_operator_enum()),
  )
  use expected <- decode.optional_field(
    "Expected",
    option.None,
    decode.optional(decode.dict(
      decode.string,
      decode_expected_attribute_value_struct(),
    )),
  )
  use expression_attribute_names <- decode.optional_field(
    "ExpressionAttributeNames",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use expression_attribute_values <- decode.optional_field(
    "ExpressionAttributeValues",
    option.None,
    decode.optional(decode.dict(decode.string, decode_attribute_value_union())),
  )
  use key <- decode.optional_field(
    "Key",
    option.None,
    decode.optional(decode.dict(decode.string, decode_attribute_value_union())),
  )
  use return_consumed_capacity <- decode.optional_field(
    "ReturnConsumedCapacity",
    option.None,
    decode.optional(decode_return_consumed_capacity_enum()),
  )
  use return_item_collection_metrics <- decode.optional_field(
    "ReturnItemCollectionMetrics",
    option.None,
    decode.optional(decode_return_item_collection_metrics_enum()),
  )
  use return_values <- decode.optional_field(
    "ReturnValues",
    option.None,
    decode.optional(decode_return_value_enum()),
  )
  use return_values_on_condition_check_failure <- decode.optional_field(
    "ReturnValuesOnConditionCheckFailure",
    option.None,
    decode.optional(decode_return_values_on_condition_check_failure_enum()),
  )
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  use update_expression <- decode.optional_field(
    "UpdateExpression",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateItemInput(
    attribute_updates: attribute_updates,
    condition_expression: condition_expression,
    conditional_operator: conditional_operator,
    expected: expected,
    expression_attribute_names: expression_attribute_names,
    expression_attribute_values: expression_attribute_values,
    key: key,
    return_consumed_capacity: return_consumed_capacity,
    return_item_collection_metrics: return_item_collection_metrics,
    return_values: return_values,
    return_values_on_condition_check_failure: return_values_on_condition_check_failure,
    table_name: table_name,
    update_expression: update_expression,
  ))
}

pub type AttributeValueUpdate {
  AttributeValueUpdate(
    action: option.Option(AttributeAction),
    value: option.Option(AttributeValue),
  )
}

pub fn attribute_value_update_default() -> AttributeValueUpdate {
  AttributeValueUpdate(action: option.None, value: option.None)
}

pub fn encode_attribute_value_update_struct(
  input: AttributeValueUpdate,
) -> json.Json {
  let pairs = []
  let pairs = case input.action {
    option.Some(v) -> [#("Action", encode_attribute_action_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.value {
    option.Some(v) -> [#("Value", encode_attribute_value_union(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_attribute_value_update_struct_top(
  input: AttributeValueUpdate,
) -> json.Json {
  let pairs = []
  let pairs = case input.action {
    option.Some(v) -> [#("Action", encode_attribute_action_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.value {
    option.Some(v) -> [#("Value", encode_attribute_value_union(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_attribute_value_update_struct() -> decode.Decoder(
  AttributeValueUpdate,
) {
  use <- decode.recursive
  use action <- decode.optional_field(
    "Action",
    option.None,
    decode.optional(decode_attribute_action_enum()),
  )
  use value <- decode.optional_field(
    "Value",
    option.None,
    decode.optional(decode_attribute_value_union()),
  )
  decode.success(AttributeValueUpdate(action: action, value: value))
}

pub type AttributeAction {
  AttributeActionAdd
  AttributeActionDelete
  AttributeActionPut
}

pub fn encode_attribute_action_enum(v: AttributeAction) -> json.Json {
  case v {
    AttributeActionAdd -> json.string("ADD")
    AttributeActionDelete -> json.string("DELETE")
    AttributeActionPut -> json.string("PUT")
  }
}

pub fn decode_attribute_action_enum() -> decode.Decoder(AttributeAction) {
  decode.then(decode.string, fn(s) {
    case s {
      "ADD" -> decode.success(AttributeActionAdd)
      "DELETE" -> decode.success(AttributeActionDelete)
      "PUT" -> decode.success(AttributeActionPut)
      _ -> decode.failure(AttributeActionAdd, "unknown enum value")
    }
  })
}

pub type UpdateItemOutput {
  UpdateItemOutput(
    attributes: option.Option(dict.Dict(String, AttributeValue)),
    consumed_capacity: option.Option(ConsumedCapacity),
    item_collection_metrics: option.Option(ItemCollectionMetrics),
  )
}

pub fn update_item_output_default() -> UpdateItemOutput {
  UpdateItemOutput(
    attributes: option.None,
    consumed_capacity: option.None,
    item_collection_metrics: option.None,
  )
}

pub fn encode_update_item_output_struct(input: UpdateItemOutput) -> json.Json {
  let pairs = []
  let pairs = case input.attributes {
    option.Some(v) -> [
      #(
        "Attributes",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.consumed_capacity {
    option.Some(v) -> [
      #("ConsumedCapacity", encode_consumed_capacity_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.item_collection_metrics {
    option.Some(v) -> [
      #("ItemCollectionMetrics", encode_item_collection_metrics_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_update_item_output_struct_top(
  input: UpdateItemOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.attributes {
    option.Some(v) -> [
      #(
        "Attributes",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_attribute_value_union(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.consumed_capacity {
    option.Some(v) -> [
      #("ConsumedCapacity", encode_consumed_capacity_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.item_collection_metrics {
    option.Some(v) -> [
      #("ItemCollectionMetrics", encode_item_collection_metrics_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_item_output_struct() -> decode.Decoder(UpdateItemOutput) {
  use <- decode.recursive
  use attributes <- decode.optional_field(
    "Attributes",
    option.None,
    decode.optional(decode.dict(decode.string, decode_attribute_value_union())),
  )
  use consumed_capacity <- decode.optional_field(
    "ConsumedCapacity",
    option.None,
    decode.optional(decode_consumed_capacity_struct()),
  )
  use item_collection_metrics <- decode.optional_field(
    "ItemCollectionMetrics",
    option.None,
    decode.optional(decode_item_collection_metrics_struct()),
  )
  decode.success(UpdateItemOutput(
    attributes: attributes,
    consumed_capacity: consumed_capacity,
    item_collection_metrics: item_collection_metrics,
  ))
}

pub type UpdateKinesisStreamingDestinationInput {
  UpdateKinesisStreamingDestinationInput(
    stream_arn: option.Option(String),
    table_name: option.Option(String),
    update_kinesis_streaming_configuration: option.Option(
      UpdateKinesisStreamingConfiguration,
    ),
  )
}

pub fn update_kinesis_streaming_destination_input_default() -> UpdateKinesisStreamingDestinationInput {
  UpdateKinesisStreamingDestinationInput(
    stream_arn: option.None,
    table_name: option.None,
    update_kinesis_streaming_configuration: option.None,
  )
}

pub fn encode_update_kinesis_streaming_destination_input_struct(
  input: UpdateKinesisStreamingDestinationInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.stream_arn {
    option.Some(v) -> [#("StreamArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.update_kinesis_streaming_configuration {
    option.Some(v) -> [
      #(
        "UpdateKinesisStreamingConfiguration",
        encode_update_kinesis_streaming_configuration_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_update_kinesis_streaming_destination_input_struct_top(
  input: UpdateKinesisStreamingDestinationInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.stream_arn {
    option.Some(v) -> [#("StreamArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.update_kinesis_streaming_configuration {
    option.Some(v) -> [
      #(
        "UpdateKinesisStreamingConfiguration",
        encode_update_kinesis_streaming_configuration_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_kinesis_streaming_destination_input_struct() -> decode.Decoder(
  UpdateKinesisStreamingDestinationInput,
) {
  use <- decode.recursive
  use stream_arn <- decode.optional_field(
    "StreamArn",
    option.None,
    decode.optional(decode.string),
  )
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  use update_kinesis_streaming_configuration <- decode.optional_field(
    "UpdateKinesisStreamingConfiguration",
    option.None,
    decode.optional(decode_update_kinesis_streaming_configuration_struct()),
  )
  decode.success(UpdateKinesisStreamingDestinationInput(
    stream_arn: stream_arn,
    table_name: table_name,
    update_kinesis_streaming_configuration: update_kinesis_streaming_configuration,
  ))
}

pub type UpdateKinesisStreamingConfiguration {
  UpdateKinesisStreamingConfiguration(
    approximate_creation_date_time_precision: option.Option(
      ApproximateCreationDateTimePrecision,
    ),
  )
}

pub fn update_kinesis_streaming_configuration_default() -> UpdateKinesisStreamingConfiguration {
  UpdateKinesisStreamingConfiguration(
    approximate_creation_date_time_precision: option.None,
  )
}

pub fn encode_update_kinesis_streaming_configuration_struct(
  input: UpdateKinesisStreamingConfiguration,
) -> json.Json {
  let pairs = []
  let pairs = case input.approximate_creation_date_time_precision {
    option.Some(v) -> [
      #(
        "ApproximateCreationDateTimePrecision",
        encode_approximate_creation_date_time_precision_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_update_kinesis_streaming_configuration_struct_top(
  input: UpdateKinesisStreamingConfiguration,
) -> json.Json {
  let pairs = []
  let pairs = case input.approximate_creation_date_time_precision {
    option.Some(v) -> [
      #(
        "ApproximateCreationDateTimePrecision",
        encode_approximate_creation_date_time_precision_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_kinesis_streaming_configuration_struct() -> decode.Decoder(
  UpdateKinesisStreamingConfiguration,
) {
  use <- decode.recursive
  use approximate_creation_date_time_precision <- decode.optional_field(
    "ApproximateCreationDateTimePrecision",
    option.None,
    decode.optional(decode_approximate_creation_date_time_precision_enum()),
  )
  decode.success(UpdateKinesisStreamingConfiguration(
    approximate_creation_date_time_precision: approximate_creation_date_time_precision,
  ))
}

pub type UpdateKinesisStreamingDestinationOutput {
  UpdateKinesisStreamingDestinationOutput(
    destination_status: option.Option(DestinationStatus),
    stream_arn: option.Option(String),
    table_name: option.Option(String),
    update_kinesis_streaming_configuration: option.Option(
      UpdateKinesisStreamingConfiguration,
    ),
  )
}

pub fn update_kinesis_streaming_destination_output_default() -> UpdateKinesisStreamingDestinationOutput {
  UpdateKinesisStreamingDestinationOutput(
    destination_status: option.None,
    stream_arn: option.None,
    table_name: option.None,
    update_kinesis_streaming_configuration: option.None,
  )
}

pub fn encode_update_kinesis_streaming_destination_output_struct(
  input: UpdateKinesisStreamingDestinationOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.destination_status {
    option.Some(v) -> [
      #("DestinationStatus", encode_destination_status_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.stream_arn {
    option.Some(v) -> [#("StreamArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.update_kinesis_streaming_configuration {
    option.Some(v) -> [
      #(
        "UpdateKinesisStreamingConfiguration",
        encode_update_kinesis_streaming_configuration_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_update_kinesis_streaming_destination_output_struct_top(
  input: UpdateKinesisStreamingDestinationOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.destination_status {
    option.Some(v) -> [
      #("DestinationStatus", encode_destination_status_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.stream_arn {
    option.Some(v) -> [#("StreamArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.update_kinesis_streaming_configuration {
    option.Some(v) -> [
      #(
        "UpdateKinesisStreamingConfiguration",
        encode_update_kinesis_streaming_configuration_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_kinesis_streaming_destination_output_struct() -> decode.Decoder(
  UpdateKinesisStreamingDestinationOutput,
) {
  use <- decode.recursive
  use destination_status <- decode.optional_field(
    "DestinationStatus",
    option.None,
    decode.optional(decode_destination_status_enum()),
  )
  use stream_arn <- decode.optional_field(
    "StreamArn",
    option.None,
    decode.optional(decode.string),
  )
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  use update_kinesis_streaming_configuration <- decode.optional_field(
    "UpdateKinesisStreamingConfiguration",
    option.None,
    decode.optional(decode_update_kinesis_streaming_configuration_struct()),
  )
  decode.success(UpdateKinesisStreamingDestinationOutput(
    destination_status: destination_status,
    stream_arn: stream_arn,
    table_name: table_name,
    update_kinesis_streaming_configuration: update_kinesis_streaming_configuration,
  ))
}

pub type UpdateTableInput {
  UpdateTableInput(
    attribute_definitions: option.Option(List(AttributeDefinition)),
    billing_mode: option.Option(BillingMode),
    deletion_protection_enabled: option.Option(Bool),
    global_secondary_index_updates: option.Option(
      List(GlobalSecondaryIndexUpdate),
    ),
    global_table_settings_replication_mode: option.Option(
      GlobalTableSettingsReplicationMode,
    ),
    global_table_witness_updates: option.Option(
      List(GlobalTableWitnessGroupUpdate),
    ),
    multi_region_consistency: option.Option(MultiRegionConsistency),
    on_demand_throughput: option.Option(OnDemandThroughput),
    provisioned_throughput: option.Option(ProvisionedThroughput),
    replica_updates: option.Option(List(ReplicationGroupUpdate)),
    sse_specification: option.Option(SSESpecification),
    stream_specification: option.Option(StreamSpecification),
    table_class: option.Option(TableClass),
    table_name: option.Option(String),
    warm_throughput: option.Option(WarmThroughput),
  )
}

pub fn update_table_input_default() -> UpdateTableInput {
  UpdateTableInput(
    attribute_definitions: option.None,
    billing_mode: option.None,
    deletion_protection_enabled: option.None,
    global_secondary_index_updates: option.None,
    global_table_settings_replication_mode: option.None,
    global_table_witness_updates: option.None,
    multi_region_consistency: option.None,
    on_demand_throughput: option.None,
    provisioned_throughput: option.None,
    replica_updates: option.None,
    sse_specification: option.None,
    stream_specification: option.None,
    table_class: option.None,
    table_name: option.None,
    warm_throughput: option.None,
  )
}

pub fn encode_update_table_input_struct(input: UpdateTableInput) -> json.Json {
  let pairs = []
  let pairs = case input.attribute_definitions {
    option.Some(v) -> [
      #(
        "AttributeDefinitions",
        fn(xs) { json.array(xs, encode_attribute_definition_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.billing_mode {
    option.Some(v) -> [#("BillingMode", encode_billing_mode_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.deletion_protection_enabled {
    option.Some(v) -> [#("DeletionProtectionEnabled", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.global_secondary_index_updates {
    option.Some(v) -> [
      #(
        "GlobalSecondaryIndexUpdates",
        fn(xs) { json.array(xs, encode_global_secondary_index_update_struct) }(
          v,
        ),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.global_table_settings_replication_mode {
    option.Some(v) -> [
      #(
        "GlobalTableSettingsReplicationMode",
        encode_global_table_settings_replication_mode_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.global_table_witness_updates {
    option.Some(v) -> [
      #(
        "GlobalTableWitnessUpdates",
        fn(xs) {
          json.array(xs, encode_global_table_witness_group_update_struct)
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.multi_region_consistency {
    option.Some(v) -> [
      #("MultiRegionConsistency", encode_multi_region_consistency_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.on_demand_throughput {
    option.Some(v) -> [
      #("OnDemandThroughput", encode_on_demand_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_throughput {
    option.Some(v) -> [
      #("ProvisionedThroughput", encode_provisioned_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.replica_updates {
    option.Some(v) -> [
      #(
        "ReplicaUpdates",
        fn(xs) { json.array(xs, encode_replication_group_update_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.sse_specification {
    option.Some(v) -> [
      #("SSESpecification", encode_sse_specification_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.stream_specification {
    option.Some(v) -> [
      #("StreamSpecification", encode_stream_specification_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_class {
    option.Some(v) -> [#("TableClass", encode_table_class_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.warm_throughput {
    option.Some(v) -> [
      #("WarmThroughput", encode_warm_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_update_table_input_struct_top(
  input: UpdateTableInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.attribute_definitions {
    option.Some(v) -> [
      #(
        "AttributeDefinitions",
        fn(xs) { json.array(xs, encode_attribute_definition_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.billing_mode {
    option.Some(v) -> [#("BillingMode", encode_billing_mode_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.deletion_protection_enabled {
    option.Some(v) -> [#("DeletionProtectionEnabled", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.global_secondary_index_updates {
    option.Some(v) -> [
      #(
        "GlobalSecondaryIndexUpdates",
        fn(xs) { json.array(xs, encode_global_secondary_index_update_struct) }(
          v,
        ),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.global_table_settings_replication_mode {
    option.Some(v) -> [
      #(
        "GlobalTableSettingsReplicationMode",
        encode_global_table_settings_replication_mode_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.global_table_witness_updates {
    option.Some(v) -> [
      #(
        "GlobalTableWitnessUpdates",
        fn(xs) {
          json.array(xs, encode_global_table_witness_group_update_struct)
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.multi_region_consistency {
    option.Some(v) -> [
      #("MultiRegionConsistency", encode_multi_region_consistency_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.on_demand_throughput {
    option.Some(v) -> [
      #("OnDemandThroughput", encode_on_demand_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_throughput {
    option.Some(v) -> [
      #("ProvisionedThroughput", encode_provisioned_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.replica_updates {
    option.Some(v) -> [
      #(
        "ReplicaUpdates",
        fn(xs) { json.array(xs, encode_replication_group_update_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.sse_specification {
    option.Some(v) -> [
      #("SSESpecification", encode_sse_specification_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.stream_specification {
    option.Some(v) -> [
      #("StreamSpecification", encode_stream_specification_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_class {
    option.Some(v) -> [#("TableClass", encode_table_class_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.warm_throughput {
    option.Some(v) -> [
      #("WarmThroughput", encode_warm_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_table_input_struct() -> decode.Decoder(UpdateTableInput) {
  use <- decode.recursive
  use attribute_definitions <- decode.optional_field(
    "AttributeDefinitions",
    option.None,
    decode.optional(decode.list(decode_attribute_definition_struct())),
  )
  use billing_mode <- decode.optional_field(
    "BillingMode",
    option.None,
    decode.optional(decode_billing_mode_enum()),
  )
  use deletion_protection_enabled <- decode.optional_field(
    "DeletionProtectionEnabled",
    option.None,
    decode.optional(decode.bool),
  )
  use global_secondary_index_updates <- decode.optional_field(
    "GlobalSecondaryIndexUpdates",
    option.None,
    decode.optional(decode.list(decode_global_secondary_index_update_struct())),
  )
  use global_table_settings_replication_mode <- decode.optional_field(
    "GlobalTableSettingsReplicationMode",
    option.None,
    decode.optional(decode_global_table_settings_replication_mode_enum()),
  )
  use global_table_witness_updates <- decode.optional_field(
    "GlobalTableWitnessUpdates",
    option.None,
    decode.optional(
      decode.list(decode_global_table_witness_group_update_struct()),
    ),
  )
  use multi_region_consistency <- decode.optional_field(
    "MultiRegionConsistency",
    option.None,
    decode.optional(decode_multi_region_consistency_enum()),
  )
  use on_demand_throughput <- decode.optional_field(
    "OnDemandThroughput",
    option.None,
    decode.optional(decode_on_demand_throughput_struct()),
  )
  use provisioned_throughput <- decode.optional_field(
    "ProvisionedThroughput",
    option.None,
    decode.optional(decode_provisioned_throughput_struct()),
  )
  use replica_updates <- decode.optional_field(
    "ReplicaUpdates",
    option.None,
    decode.optional(decode.list(decode_replication_group_update_struct())),
  )
  use sse_specification <- decode.optional_field(
    "SSESpecification",
    option.None,
    decode.optional(decode_sse_specification_struct()),
  )
  use stream_specification <- decode.optional_field(
    "StreamSpecification",
    option.None,
    decode.optional(decode_stream_specification_struct()),
  )
  use table_class <- decode.optional_field(
    "TableClass",
    option.None,
    decode.optional(decode_table_class_enum()),
  )
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  use warm_throughput <- decode.optional_field(
    "WarmThroughput",
    option.None,
    decode.optional(decode_warm_throughput_struct()),
  )
  decode.success(UpdateTableInput(
    attribute_definitions: attribute_definitions,
    billing_mode: billing_mode,
    deletion_protection_enabled: deletion_protection_enabled,
    global_secondary_index_updates: global_secondary_index_updates,
    global_table_settings_replication_mode: global_table_settings_replication_mode,
    global_table_witness_updates: global_table_witness_updates,
    multi_region_consistency: multi_region_consistency,
    on_demand_throughput: on_demand_throughput,
    provisioned_throughput: provisioned_throughput,
    replica_updates: replica_updates,
    sse_specification: sse_specification,
    stream_specification: stream_specification,
    table_class: table_class,
    table_name: table_name,
    warm_throughput: warm_throughput,
  ))
}

pub type GlobalSecondaryIndexUpdate {
  GlobalSecondaryIndexUpdate(
    create: option.Option(CreateGlobalSecondaryIndexAction),
    delete: option.Option(DeleteGlobalSecondaryIndexAction),
    update: option.Option(UpdateGlobalSecondaryIndexAction),
  )
}

pub fn global_secondary_index_update_default() -> GlobalSecondaryIndexUpdate {
  GlobalSecondaryIndexUpdate(
    create: option.None,
    delete: option.None,
    update: option.None,
  )
}

pub fn encode_global_secondary_index_update_struct(
  input: GlobalSecondaryIndexUpdate,
) -> json.Json {
  let pairs = []
  let pairs = case input.create {
    option.Some(v) -> [
      #("Create", encode_create_global_secondary_index_action_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.delete {
    option.Some(v) -> [
      #("Delete", encode_delete_global_secondary_index_action_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.update {
    option.Some(v) -> [
      #("Update", encode_update_global_secondary_index_action_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_global_secondary_index_update_struct_top(
  input: GlobalSecondaryIndexUpdate,
) -> json.Json {
  let pairs = []
  let pairs = case input.create {
    option.Some(v) -> [
      #("Create", encode_create_global_secondary_index_action_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.delete {
    option.Some(v) -> [
      #("Delete", encode_delete_global_secondary_index_action_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.update {
    option.Some(v) -> [
      #("Update", encode_update_global_secondary_index_action_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_global_secondary_index_update_struct() -> decode.Decoder(
  GlobalSecondaryIndexUpdate,
) {
  use <- decode.recursive
  use create <- decode.optional_field(
    "Create",
    option.None,
    decode.optional(decode_create_global_secondary_index_action_struct()),
  )
  use delete <- decode.optional_field(
    "Delete",
    option.None,
    decode.optional(decode_delete_global_secondary_index_action_struct()),
  )
  use update <- decode.optional_field(
    "Update",
    option.None,
    decode.optional(decode_update_global_secondary_index_action_struct()),
  )
  decode.success(GlobalSecondaryIndexUpdate(
    create: create,
    delete: delete,
    update: update,
  ))
}

pub type CreateGlobalSecondaryIndexAction {
  CreateGlobalSecondaryIndexAction(
    index_name: option.Option(String),
    key_schema: option.Option(List(KeySchemaElement)),
    on_demand_throughput: option.Option(OnDemandThroughput),
    projection: option.Option(Projection),
    provisioned_throughput: option.Option(ProvisionedThroughput),
    warm_throughput: option.Option(WarmThroughput),
  )
}

pub fn create_global_secondary_index_action_default() -> CreateGlobalSecondaryIndexAction {
  CreateGlobalSecondaryIndexAction(
    index_name: option.None,
    key_schema: option.None,
    on_demand_throughput: option.None,
    projection: option.None,
    provisioned_throughput: option.None,
    warm_throughput: option.None,
  )
}

pub fn encode_create_global_secondary_index_action_struct(
  input: CreateGlobalSecondaryIndexAction,
) -> json.Json {
  let pairs = []
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.key_schema {
    option.Some(v) -> [
      #(
        "KeySchema",
        fn(xs) { json.array(xs, encode_key_schema_element_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.on_demand_throughput {
    option.Some(v) -> [
      #("OnDemandThroughput", encode_on_demand_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.projection {
    option.Some(v) -> [#("Projection", encode_projection_struct(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.provisioned_throughput {
    option.Some(v) -> [
      #("ProvisionedThroughput", encode_provisioned_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.warm_throughput {
    option.Some(v) -> [
      #("WarmThroughput", encode_warm_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_create_global_secondary_index_action_struct_top(
  input: CreateGlobalSecondaryIndexAction,
) -> json.Json {
  let pairs = []
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.key_schema {
    option.Some(v) -> [
      #(
        "KeySchema",
        fn(xs) { json.array(xs, encode_key_schema_element_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.on_demand_throughput {
    option.Some(v) -> [
      #("OnDemandThroughput", encode_on_demand_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.projection {
    option.Some(v) -> [#("Projection", encode_projection_struct(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.provisioned_throughput {
    option.Some(v) -> [
      #("ProvisionedThroughput", encode_provisioned_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.warm_throughput {
    option.Some(v) -> [
      #("WarmThroughput", encode_warm_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_create_global_secondary_index_action_struct() -> decode.Decoder(
  CreateGlobalSecondaryIndexAction,
) {
  use <- decode.recursive
  use index_name <- decode.optional_field(
    "IndexName",
    option.None,
    decode.optional(decode.string),
  )
  use key_schema <- decode.optional_field(
    "KeySchema",
    option.None,
    decode.optional(decode.list(decode_key_schema_element_struct())),
  )
  use on_demand_throughput <- decode.optional_field(
    "OnDemandThroughput",
    option.None,
    decode.optional(decode_on_demand_throughput_struct()),
  )
  use projection <- decode.optional_field(
    "Projection",
    option.None,
    decode.optional(decode_projection_struct()),
  )
  use provisioned_throughput <- decode.optional_field(
    "ProvisionedThroughput",
    option.None,
    decode.optional(decode_provisioned_throughput_struct()),
  )
  use warm_throughput <- decode.optional_field(
    "WarmThroughput",
    option.None,
    decode.optional(decode_warm_throughput_struct()),
  )
  decode.success(CreateGlobalSecondaryIndexAction(
    index_name: index_name,
    key_schema: key_schema,
    on_demand_throughput: on_demand_throughput,
    projection: projection,
    provisioned_throughput: provisioned_throughput,
    warm_throughput: warm_throughput,
  ))
}

pub type DeleteGlobalSecondaryIndexAction {
  DeleteGlobalSecondaryIndexAction(index_name: option.Option(String))
}

pub fn delete_global_secondary_index_action_default() -> DeleteGlobalSecondaryIndexAction {
  DeleteGlobalSecondaryIndexAction(index_name: option.None)
}

pub fn encode_delete_global_secondary_index_action_struct(
  input: DeleteGlobalSecondaryIndexAction,
) -> json.Json {
  let pairs = []
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_delete_global_secondary_index_action_struct_top(
  input: DeleteGlobalSecondaryIndexAction,
) -> json.Json {
  let pairs = []
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_delete_global_secondary_index_action_struct() -> decode.Decoder(
  DeleteGlobalSecondaryIndexAction,
) {
  use <- decode.recursive
  use index_name <- decode.optional_field(
    "IndexName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteGlobalSecondaryIndexAction(index_name: index_name))
}

pub type UpdateGlobalSecondaryIndexAction {
  UpdateGlobalSecondaryIndexAction(
    index_name: option.Option(String),
    on_demand_throughput: option.Option(OnDemandThroughput),
    provisioned_throughput: option.Option(ProvisionedThroughput),
    warm_throughput: option.Option(WarmThroughput),
  )
}

pub fn update_global_secondary_index_action_default() -> UpdateGlobalSecondaryIndexAction {
  UpdateGlobalSecondaryIndexAction(
    index_name: option.None,
    on_demand_throughput: option.None,
    provisioned_throughput: option.None,
    warm_throughput: option.None,
  )
}

pub fn encode_update_global_secondary_index_action_struct(
  input: UpdateGlobalSecondaryIndexAction,
) -> json.Json {
  let pairs = []
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.on_demand_throughput {
    option.Some(v) -> [
      #("OnDemandThroughput", encode_on_demand_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_throughput {
    option.Some(v) -> [
      #("ProvisionedThroughput", encode_provisioned_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.warm_throughput {
    option.Some(v) -> [
      #("WarmThroughput", encode_warm_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_update_global_secondary_index_action_struct_top(
  input: UpdateGlobalSecondaryIndexAction,
) -> json.Json {
  let pairs = []
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.on_demand_throughput {
    option.Some(v) -> [
      #("OnDemandThroughput", encode_on_demand_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_throughput {
    option.Some(v) -> [
      #("ProvisionedThroughput", encode_provisioned_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.warm_throughput {
    option.Some(v) -> [
      #("WarmThroughput", encode_warm_throughput_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_global_secondary_index_action_struct() -> decode.Decoder(
  UpdateGlobalSecondaryIndexAction,
) {
  use <- decode.recursive
  use index_name <- decode.optional_field(
    "IndexName",
    option.None,
    decode.optional(decode.string),
  )
  use on_demand_throughput <- decode.optional_field(
    "OnDemandThroughput",
    option.None,
    decode.optional(decode_on_demand_throughput_struct()),
  )
  use provisioned_throughput <- decode.optional_field(
    "ProvisionedThroughput",
    option.None,
    decode.optional(decode_provisioned_throughput_struct()),
  )
  use warm_throughput <- decode.optional_field(
    "WarmThroughput",
    option.None,
    decode.optional(decode_warm_throughput_struct()),
  )
  decode.success(UpdateGlobalSecondaryIndexAction(
    index_name: index_name,
    on_demand_throughput: on_demand_throughput,
    provisioned_throughput: provisioned_throughput,
    warm_throughput: warm_throughput,
  ))
}

pub type GlobalTableWitnessGroupUpdate {
  GlobalTableWitnessGroupUpdate(
    create: option.Option(CreateGlobalTableWitnessGroupMemberAction),
    delete: option.Option(DeleteGlobalTableWitnessGroupMemberAction),
  )
}

pub fn global_table_witness_group_update_default() -> GlobalTableWitnessGroupUpdate {
  GlobalTableWitnessGroupUpdate(create: option.None, delete: option.None)
}

pub fn encode_global_table_witness_group_update_struct(
  input: GlobalTableWitnessGroupUpdate,
) -> json.Json {
  let pairs = []
  let pairs = case input.create {
    option.Some(v) -> [
      #(
        "Create",
        encode_create_global_table_witness_group_member_action_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.delete {
    option.Some(v) -> [
      #(
        "Delete",
        encode_delete_global_table_witness_group_member_action_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_global_table_witness_group_update_struct_top(
  input: GlobalTableWitnessGroupUpdate,
) -> json.Json {
  let pairs = []
  let pairs = case input.create {
    option.Some(v) -> [
      #(
        "Create",
        encode_create_global_table_witness_group_member_action_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.delete {
    option.Some(v) -> [
      #(
        "Delete",
        encode_delete_global_table_witness_group_member_action_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_global_table_witness_group_update_struct() -> decode.Decoder(
  GlobalTableWitnessGroupUpdate,
) {
  use <- decode.recursive
  use create <- decode.optional_field(
    "Create",
    option.None,
    decode.optional(
      decode_create_global_table_witness_group_member_action_struct(),
    ),
  )
  use delete <- decode.optional_field(
    "Delete",
    option.None,
    decode.optional(
      decode_delete_global_table_witness_group_member_action_struct(),
    ),
  )
  decode.success(GlobalTableWitnessGroupUpdate(create: create, delete: delete))
}

pub type CreateGlobalTableWitnessGroupMemberAction {
  CreateGlobalTableWitnessGroupMemberAction(region_name: option.Option(String))
}

pub fn create_global_table_witness_group_member_action_default() -> CreateGlobalTableWitnessGroupMemberAction {
  CreateGlobalTableWitnessGroupMemberAction(region_name: option.None)
}

pub fn encode_create_global_table_witness_group_member_action_struct(
  input: CreateGlobalTableWitnessGroupMemberAction,
) -> json.Json {
  let pairs = []
  let pairs = case input.region_name {
    option.Some(v) -> [#("RegionName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_create_global_table_witness_group_member_action_struct_top(
  input: CreateGlobalTableWitnessGroupMemberAction,
) -> json.Json {
  let pairs = []
  let pairs = case input.region_name {
    option.Some(v) -> [#("RegionName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_create_global_table_witness_group_member_action_struct() -> decode.Decoder(
  CreateGlobalTableWitnessGroupMemberAction,
) {
  use <- decode.recursive
  use region_name <- decode.optional_field(
    "RegionName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(CreateGlobalTableWitnessGroupMemberAction(
    region_name: region_name,
  ))
}

pub type DeleteGlobalTableWitnessGroupMemberAction {
  DeleteGlobalTableWitnessGroupMemberAction(region_name: option.Option(String))
}

pub fn delete_global_table_witness_group_member_action_default() -> DeleteGlobalTableWitnessGroupMemberAction {
  DeleteGlobalTableWitnessGroupMemberAction(region_name: option.None)
}

pub fn encode_delete_global_table_witness_group_member_action_struct(
  input: DeleteGlobalTableWitnessGroupMemberAction,
) -> json.Json {
  let pairs = []
  let pairs = case input.region_name {
    option.Some(v) -> [#("RegionName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_delete_global_table_witness_group_member_action_struct_top(
  input: DeleteGlobalTableWitnessGroupMemberAction,
) -> json.Json {
  let pairs = []
  let pairs = case input.region_name {
    option.Some(v) -> [#("RegionName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_delete_global_table_witness_group_member_action_struct() -> decode.Decoder(
  DeleteGlobalTableWitnessGroupMemberAction,
) {
  use <- decode.recursive
  use region_name <- decode.optional_field(
    "RegionName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteGlobalTableWitnessGroupMemberAction(
    region_name: region_name,
  ))
}

pub type ReplicationGroupUpdate {
  ReplicationGroupUpdate(
    create: option.Option(CreateReplicationGroupMemberAction),
    delete: option.Option(DeleteReplicationGroupMemberAction),
    update: option.Option(UpdateReplicationGroupMemberAction),
  )
}

pub fn replication_group_update_default() -> ReplicationGroupUpdate {
  ReplicationGroupUpdate(
    create: option.None,
    delete: option.None,
    update: option.None,
  )
}

pub fn encode_replication_group_update_struct(
  input: ReplicationGroupUpdate,
) -> json.Json {
  let pairs = []
  let pairs = case input.create {
    option.Some(v) -> [
      #("Create", encode_create_replication_group_member_action_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.delete {
    option.Some(v) -> [
      #("Delete", encode_delete_replication_group_member_action_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.update {
    option.Some(v) -> [
      #("Update", encode_update_replication_group_member_action_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_replication_group_update_struct_top(
  input: ReplicationGroupUpdate,
) -> json.Json {
  let pairs = []
  let pairs = case input.create {
    option.Some(v) -> [
      #("Create", encode_create_replication_group_member_action_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.delete {
    option.Some(v) -> [
      #("Delete", encode_delete_replication_group_member_action_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.update {
    option.Some(v) -> [
      #("Update", encode_update_replication_group_member_action_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_replication_group_update_struct() -> decode.Decoder(
  ReplicationGroupUpdate,
) {
  use <- decode.recursive
  use create <- decode.optional_field(
    "Create",
    option.None,
    decode.optional(decode_create_replication_group_member_action_struct()),
  )
  use delete <- decode.optional_field(
    "Delete",
    option.None,
    decode.optional(decode_delete_replication_group_member_action_struct()),
  )
  use update <- decode.optional_field(
    "Update",
    option.None,
    decode.optional(decode_update_replication_group_member_action_struct()),
  )
  decode.success(ReplicationGroupUpdate(
    create: create,
    delete: delete,
    update: update,
  ))
}

pub type CreateReplicationGroupMemberAction {
  CreateReplicationGroupMemberAction(
    global_secondary_indexes: option.Option(List(ReplicaGlobalSecondaryIndex)),
    kms_master_key_id: option.Option(String),
    on_demand_throughput_override: option.Option(OnDemandThroughputOverride),
    provisioned_throughput_override: option.Option(
      ProvisionedThroughputOverride,
    ),
    region_name: option.Option(String),
    table_class_override: option.Option(TableClass),
  )
}

pub fn create_replication_group_member_action_default() -> CreateReplicationGroupMemberAction {
  CreateReplicationGroupMemberAction(
    global_secondary_indexes: option.None,
    kms_master_key_id: option.None,
    on_demand_throughput_override: option.None,
    provisioned_throughput_override: option.None,
    region_name: option.None,
    table_class_override: option.None,
  )
}

pub fn encode_create_replication_group_member_action_struct(
  input: CreateReplicationGroupMemberAction,
) -> json.Json {
  let pairs = []
  let pairs = case input.global_secondary_indexes {
    option.Some(v) -> [
      #(
        "GlobalSecondaryIndexes",
        fn(xs) { json.array(xs, encode_replica_global_secondary_index_struct) }(
          v,
        ),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.kms_master_key_id {
    option.Some(v) -> [#("KMSMasterKeyId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.on_demand_throughput_override {
    option.Some(v) -> [
      #(
        "OnDemandThroughputOverride",
        encode_on_demand_throughput_override_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_throughput_override {
    option.Some(v) -> [
      #(
        "ProvisionedThroughputOverride",
        encode_provisioned_throughput_override_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.region_name {
    option.Some(v) -> [#("RegionName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_class_override {
    option.Some(v) -> [
      #("TableClassOverride", encode_table_class_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_create_replication_group_member_action_struct_top(
  input: CreateReplicationGroupMemberAction,
) -> json.Json {
  let pairs = []
  let pairs = case input.global_secondary_indexes {
    option.Some(v) -> [
      #(
        "GlobalSecondaryIndexes",
        fn(xs) { json.array(xs, encode_replica_global_secondary_index_struct) }(
          v,
        ),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.kms_master_key_id {
    option.Some(v) -> [#("KMSMasterKeyId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.on_demand_throughput_override {
    option.Some(v) -> [
      #(
        "OnDemandThroughputOverride",
        encode_on_demand_throughput_override_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_throughput_override {
    option.Some(v) -> [
      #(
        "ProvisionedThroughputOverride",
        encode_provisioned_throughput_override_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.region_name {
    option.Some(v) -> [#("RegionName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_class_override {
    option.Some(v) -> [
      #("TableClassOverride", encode_table_class_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_create_replication_group_member_action_struct() -> decode.Decoder(
  CreateReplicationGroupMemberAction,
) {
  use <- decode.recursive
  use global_secondary_indexes <- decode.optional_field(
    "GlobalSecondaryIndexes",
    option.None,
    decode.optional(decode.list(decode_replica_global_secondary_index_struct())),
  )
  use kms_master_key_id <- decode.optional_field(
    "KMSMasterKeyId",
    option.None,
    decode.optional(decode.string),
  )
  use on_demand_throughput_override <- decode.optional_field(
    "OnDemandThroughputOverride",
    option.None,
    decode.optional(decode_on_demand_throughput_override_struct()),
  )
  use provisioned_throughput_override <- decode.optional_field(
    "ProvisionedThroughputOverride",
    option.None,
    decode.optional(decode_provisioned_throughput_override_struct()),
  )
  use region_name <- decode.optional_field(
    "RegionName",
    option.None,
    decode.optional(decode.string),
  )
  use table_class_override <- decode.optional_field(
    "TableClassOverride",
    option.None,
    decode.optional(decode_table_class_enum()),
  )
  decode.success(CreateReplicationGroupMemberAction(
    global_secondary_indexes: global_secondary_indexes,
    kms_master_key_id: kms_master_key_id,
    on_demand_throughput_override: on_demand_throughput_override,
    provisioned_throughput_override: provisioned_throughput_override,
    region_name: region_name,
    table_class_override: table_class_override,
  ))
}

pub type ReplicaGlobalSecondaryIndex {
  ReplicaGlobalSecondaryIndex(
    index_name: option.Option(String),
    on_demand_throughput_override: option.Option(OnDemandThroughputOverride),
    provisioned_throughput_override: option.Option(
      ProvisionedThroughputOverride,
    ),
  )
}

pub fn replica_global_secondary_index_default() -> ReplicaGlobalSecondaryIndex {
  ReplicaGlobalSecondaryIndex(
    index_name: option.None,
    on_demand_throughput_override: option.None,
    provisioned_throughput_override: option.None,
  )
}

pub fn encode_replica_global_secondary_index_struct(
  input: ReplicaGlobalSecondaryIndex,
) -> json.Json {
  let pairs = []
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.on_demand_throughput_override {
    option.Some(v) -> [
      #(
        "OnDemandThroughputOverride",
        encode_on_demand_throughput_override_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_throughput_override {
    option.Some(v) -> [
      #(
        "ProvisionedThroughputOverride",
        encode_provisioned_throughput_override_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_replica_global_secondary_index_struct_top(
  input: ReplicaGlobalSecondaryIndex,
) -> json.Json {
  let pairs = []
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.on_demand_throughput_override {
    option.Some(v) -> [
      #(
        "OnDemandThroughputOverride",
        encode_on_demand_throughput_override_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_throughput_override {
    option.Some(v) -> [
      #(
        "ProvisionedThroughputOverride",
        encode_provisioned_throughput_override_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_replica_global_secondary_index_struct() -> decode.Decoder(
  ReplicaGlobalSecondaryIndex,
) {
  use <- decode.recursive
  use index_name <- decode.optional_field(
    "IndexName",
    option.None,
    decode.optional(decode.string),
  )
  use on_demand_throughput_override <- decode.optional_field(
    "OnDemandThroughputOverride",
    option.None,
    decode.optional(decode_on_demand_throughput_override_struct()),
  )
  use provisioned_throughput_override <- decode.optional_field(
    "ProvisionedThroughputOverride",
    option.None,
    decode.optional(decode_provisioned_throughput_override_struct()),
  )
  decode.success(ReplicaGlobalSecondaryIndex(
    index_name: index_name,
    on_demand_throughput_override: on_demand_throughput_override,
    provisioned_throughput_override: provisioned_throughput_override,
  ))
}

pub type DeleteReplicationGroupMemberAction {
  DeleteReplicationGroupMemberAction(region_name: option.Option(String))
}

pub fn delete_replication_group_member_action_default() -> DeleteReplicationGroupMemberAction {
  DeleteReplicationGroupMemberAction(region_name: option.None)
}

pub fn encode_delete_replication_group_member_action_struct(
  input: DeleteReplicationGroupMemberAction,
) -> json.Json {
  let pairs = []
  let pairs = case input.region_name {
    option.Some(v) -> [#("RegionName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_delete_replication_group_member_action_struct_top(
  input: DeleteReplicationGroupMemberAction,
) -> json.Json {
  let pairs = []
  let pairs = case input.region_name {
    option.Some(v) -> [#("RegionName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_delete_replication_group_member_action_struct() -> decode.Decoder(
  DeleteReplicationGroupMemberAction,
) {
  use <- decode.recursive
  use region_name <- decode.optional_field(
    "RegionName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteReplicationGroupMemberAction(region_name: region_name))
}

pub type UpdateReplicationGroupMemberAction {
  UpdateReplicationGroupMemberAction(
    global_secondary_indexes: option.Option(List(ReplicaGlobalSecondaryIndex)),
    kms_master_key_id: option.Option(String),
    on_demand_throughput_override: option.Option(OnDemandThroughputOverride),
    provisioned_throughput_override: option.Option(
      ProvisionedThroughputOverride,
    ),
    region_name: option.Option(String),
    table_class_override: option.Option(TableClass),
  )
}

pub fn update_replication_group_member_action_default() -> UpdateReplicationGroupMemberAction {
  UpdateReplicationGroupMemberAction(
    global_secondary_indexes: option.None,
    kms_master_key_id: option.None,
    on_demand_throughput_override: option.None,
    provisioned_throughput_override: option.None,
    region_name: option.None,
    table_class_override: option.None,
  )
}

pub fn encode_update_replication_group_member_action_struct(
  input: UpdateReplicationGroupMemberAction,
) -> json.Json {
  let pairs = []
  let pairs = case input.global_secondary_indexes {
    option.Some(v) -> [
      #(
        "GlobalSecondaryIndexes",
        fn(xs) { json.array(xs, encode_replica_global_secondary_index_struct) }(
          v,
        ),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.kms_master_key_id {
    option.Some(v) -> [#("KMSMasterKeyId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.on_demand_throughput_override {
    option.Some(v) -> [
      #(
        "OnDemandThroughputOverride",
        encode_on_demand_throughput_override_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_throughput_override {
    option.Some(v) -> [
      #(
        "ProvisionedThroughputOverride",
        encode_provisioned_throughput_override_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.region_name {
    option.Some(v) -> [#("RegionName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_class_override {
    option.Some(v) -> [
      #("TableClassOverride", encode_table_class_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_update_replication_group_member_action_struct_top(
  input: UpdateReplicationGroupMemberAction,
) -> json.Json {
  let pairs = []
  let pairs = case input.global_secondary_indexes {
    option.Some(v) -> [
      #(
        "GlobalSecondaryIndexes",
        fn(xs) { json.array(xs, encode_replica_global_secondary_index_struct) }(
          v,
        ),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.kms_master_key_id {
    option.Some(v) -> [#("KMSMasterKeyId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.on_demand_throughput_override {
    option.Some(v) -> [
      #(
        "OnDemandThroughputOverride",
        encode_on_demand_throughput_override_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_throughput_override {
    option.Some(v) -> [
      #(
        "ProvisionedThroughputOverride",
        encode_provisioned_throughput_override_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.region_name {
    option.Some(v) -> [#("RegionName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.table_class_override {
    option.Some(v) -> [
      #("TableClassOverride", encode_table_class_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_replication_group_member_action_struct() -> decode.Decoder(
  UpdateReplicationGroupMemberAction,
) {
  use <- decode.recursive
  use global_secondary_indexes <- decode.optional_field(
    "GlobalSecondaryIndexes",
    option.None,
    decode.optional(decode.list(decode_replica_global_secondary_index_struct())),
  )
  use kms_master_key_id <- decode.optional_field(
    "KMSMasterKeyId",
    option.None,
    decode.optional(decode.string),
  )
  use on_demand_throughput_override <- decode.optional_field(
    "OnDemandThroughputOverride",
    option.None,
    decode.optional(decode_on_demand_throughput_override_struct()),
  )
  use provisioned_throughput_override <- decode.optional_field(
    "ProvisionedThroughputOverride",
    option.None,
    decode.optional(decode_provisioned_throughput_override_struct()),
  )
  use region_name <- decode.optional_field(
    "RegionName",
    option.None,
    decode.optional(decode.string),
  )
  use table_class_override <- decode.optional_field(
    "TableClassOverride",
    option.None,
    decode.optional(decode_table_class_enum()),
  )
  decode.success(UpdateReplicationGroupMemberAction(
    global_secondary_indexes: global_secondary_indexes,
    kms_master_key_id: kms_master_key_id,
    on_demand_throughput_override: on_demand_throughput_override,
    provisioned_throughput_override: provisioned_throughput_override,
    region_name: region_name,
    table_class_override: table_class_override,
  ))
}

pub type UpdateTableOutput {
  UpdateTableOutput(table_description: option.Option(TableDescription))
}

pub fn update_table_output_default() -> UpdateTableOutput {
  UpdateTableOutput(table_description: option.None)
}

pub fn encode_update_table_output_struct(
  input: UpdateTableOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.table_description {
    option.Some(v) -> [
      #("TableDescription", encode_table_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_update_table_output_struct_top(
  input: UpdateTableOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.table_description {
    option.Some(v) -> [
      #("TableDescription", encode_table_description_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_table_output_struct() -> decode.Decoder(UpdateTableOutput) {
  use <- decode.recursive
  use table_description <- decode.optional_field(
    "TableDescription",
    option.None,
    decode.optional(decode_table_description_struct()),
  )
  decode.success(UpdateTableOutput(table_description: table_description))
}

pub type UpdateTableReplicaAutoScalingInput {
  UpdateTableReplicaAutoScalingInput(
    global_secondary_index_updates: option.Option(
      List(GlobalSecondaryIndexAutoScalingUpdate),
    ),
    provisioned_write_capacity_auto_scaling_update: option.Option(
      AutoScalingSettingsUpdate,
    ),
    replica_updates: option.Option(List(ReplicaAutoScalingUpdate)),
    table_name: option.Option(String),
  )
}

pub fn update_table_replica_auto_scaling_input_default() -> UpdateTableReplicaAutoScalingInput {
  UpdateTableReplicaAutoScalingInput(
    global_secondary_index_updates: option.None,
    provisioned_write_capacity_auto_scaling_update: option.None,
    replica_updates: option.None,
    table_name: option.None,
  )
}

pub fn encode_update_table_replica_auto_scaling_input_struct(
  input: UpdateTableReplicaAutoScalingInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.global_secondary_index_updates {
    option.Some(v) -> [
      #(
        "GlobalSecondaryIndexUpdates",
        fn(xs) {
          json.array(
            xs,
            encode_global_secondary_index_auto_scaling_update_struct,
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_write_capacity_auto_scaling_update {
    option.Some(v) -> [
      #(
        "ProvisionedWriteCapacityAutoScalingUpdate",
        encode_auto_scaling_settings_update_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.replica_updates {
    option.Some(v) -> [
      #(
        "ReplicaUpdates",
        fn(xs) { json.array(xs, encode_replica_auto_scaling_update_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_update_table_replica_auto_scaling_input_struct_top(
  input: UpdateTableReplicaAutoScalingInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.global_secondary_index_updates {
    option.Some(v) -> [
      #(
        "GlobalSecondaryIndexUpdates",
        fn(xs) {
          json.array(
            xs,
            encode_global_secondary_index_auto_scaling_update_struct,
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.provisioned_write_capacity_auto_scaling_update {
    option.Some(v) -> [
      #(
        "ProvisionedWriteCapacityAutoScalingUpdate",
        encode_auto_scaling_settings_update_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.replica_updates {
    option.Some(v) -> [
      #(
        "ReplicaUpdates",
        fn(xs) { json.array(xs, encode_replica_auto_scaling_update_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_table_replica_auto_scaling_input_struct() -> decode.Decoder(
  UpdateTableReplicaAutoScalingInput,
) {
  use <- decode.recursive
  use global_secondary_index_updates <- decode.optional_field(
    "GlobalSecondaryIndexUpdates",
    option.None,
    decode.optional(
      decode.list(decode_global_secondary_index_auto_scaling_update_struct()),
    ),
  )
  use provisioned_write_capacity_auto_scaling_update <- decode.optional_field(
    "ProvisionedWriteCapacityAutoScalingUpdate",
    option.None,
    decode.optional(decode_auto_scaling_settings_update_struct()),
  )
  use replica_updates <- decode.optional_field(
    "ReplicaUpdates",
    option.None,
    decode.optional(decode.list(decode_replica_auto_scaling_update_struct())),
  )
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateTableReplicaAutoScalingInput(
    global_secondary_index_updates: global_secondary_index_updates,
    provisioned_write_capacity_auto_scaling_update: provisioned_write_capacity_auto_scaling_update,
    replica_updates: replica_updates,
    table_name: table_name,
  ))
}

pub type GlobalSecondaryIndexAutoScalingUpdate {
  GlobalSecondaryIndexAutoScalingUpdate(
    index_name: option.Option(String),
    provisioned_write_capacity_auto_scaling_update: option.Option(
      AutoScalingSettingsUpdate,
    ),
  )
}

pub fn global_secondary_index_auto_scaling_update_default() -> GlobalSecondaryIndexAutoScalingUpdate {
  GlobalSecondaryIndexAutoScalingUpdate(
    index_name: option.None,
    provisioned_write_capacity_auto_scaling_update: option.None,
  )
}

pub fn encode_global_secondary_index_auto_scaling_update_struct(
  input: GlobalSecondaryIndexAutoScalingUpdate,
) -> json.Json {
  let pairs = []
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.provisioned_write_capacity_auto_scaling_update {
    option.Some(v) -> [
      #(
        "ProvisionedWriteCapacityAutoScalingUpdate",
        encode_auto_scaling_settings_update_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_global_secondary_index_auto_scaling_update_struct_top(
  input: GlobalSecondaryIndexAutoScalingUpdate,
) -> json.Json {
  let pairs = []
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.provisioned_write_capacity_auto_scaling_update {
    option.Some(v) -> [
      #(
        "ProvisionedWriteCapacityAutoScalingUpdate",
        encode_auto_scaling_settings_update_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_global_secondary_index_auto_scaling_update_struct() -> decode.Decoder(
  GlobalSecondaryIndexAutoScalingUpdate,
) {
  use <- decode.recursive
  use index_name <- decode.optional_field(
    "IndexName",
    option.None,
    decode.optional(decode.string),
  )
  use provisioned_write_capacity_auto_scaling_update <- decode.optional_field(
    "ProvisionedWriteCapacityAutoScalingUpdate",
    option.None,
    decode.optional(decode_auto_scaling_settings_update_struct()),
  )
  decode.success(GlobalSecondaryIndexAutoScalingUpdate(
    index_name: index_name,
    provisioned_write_capacity_auto_scaling_update: provisioned_write_capacity_auto_scaling_update,
  ))
}

pub type ReplicaAutoScalingUpdate {
  ReplicaAutoScalingUpdate(
    region_name: option.Option(String),
    replica_global_secondary_index_updates: option.Option(
      List(ReplicaGlobalSecondaryIndexAutoScalingUpdate),
    ),
    replica_provisioned_read_capacity_auto_scaling_update: option.Option(
      AutoScalingSettingsUpdate,
    ),
  )
}

pub fn replica_auto_scaling_update_default() -> ReplicaAutoScalingUpdate {
  ReplicaAutoScalingUpdate(
    region_name: option.None,
    replica_global_secondary_index_updates: option.None,
    replica_provisioned_read_capacity_auto_scaling_update: option.None,
  )
}

pub fn encode_replica_auto_scaling_update_struct(
  input: ReplicaAutoScalingUpdate,
) -> json.Json {
  let pairs = []
  let pairs = case input.region_name {
    option.Some(v) -> [#("RegionName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.replica_global_secondary_index_updates {
    option.Some(v) -> [
      #(
        "ReplicaGlobalSecondaryIndexUpdates",
        fn(xs) {
          json.array(
            xs,
            encode_replica_global_secondary_index_auto_scaling_update_struct,
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.replica_provisioned_read_capacity_auto_scaling_update {
    option.Some(v) -> [
      #(
        "ReplicaProvisionedReadCapacityAutoScalingUpdate",
        encode_auto_scaling_settings_update_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_replica_auto_scaling_update_struct_top(
  input: ReplicaAutoScalingUpdate,
) -> json.Json {
  let pairs = []
  let pairs = case input.region_name {
    option.Some(v) -> [#("RegionName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.replica_global_secondary_index_updates {
    option.Some(v) -> [
      #(
        "ReplicaGlobalSecondaryIndexUpdates",
        fn(xs) {
          json.array(
            xs,
            encode_replica_global_secondary_index_auto_scaling_update_struct,
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.replica_provisioned_read_capacity_auto_scaling_update {
    option.Some(v) -> [
      #(
        "ReplicaProvisionedReadCapacityAutoScalingUpdate",
        encode_auto_scaling_settings_update_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_replica_auto_scaling_update_struct() -> decode.Decoder(
  ReplicaAutoScalingUpdate,
) {
  use <- decode.recursive
  use region_name <- decode.optional_field(
    "RegionName",
    option.None,
    decode.optional(decode.string),
  )
  use replica_global_secondary_index_updates <- decode.optional_field(
    "ReplicaGlobalSecondaryIndexUpdates",
    option.None,
    decode.optional(
      decode.list(
        decode_replica_global_secondary_index_auto_scaling_update_struct(),
      ),
    ),
  )
  use replica_provisioned_read_capacity_auto_scaling_update <- decode.optional_field(
    "ReplicaProvisionedReadCapacityAutoScalingUpdate",
    option.None,
    decode.optional(decode_auto_scaling_settings_update_struct()),
  )
  decode.success(ReplicaAutoScalingUpdate(
    region_name: region_name,
    replica_global_secondary_index_updates: replica_global_secondary_index_updates,
    replica_provisioned_read_capacity_auto_scaling_update: replica_provisioned_read_capacity_auto_scaling_update,
  ))
}

pub type ReplicaGlobalSecondaryIndexAutoScalingUpdate {
  ReplicaGlobalSecondaryIndexAutoScalingUpdate(
    index_name: option.Option(String),
    provisioned_read_capacity_auto_scaling_update: option.Option(
      AutoScalingSettingsUpdate,
    ),
  )
}

pub fn replica_global_secondary_index_auto_scaling_update_default() -> ReplicaGlobalSecondaryIndexAutoScalingUpdate {
  ReplicaGlobalSecondaryIndexAutoScalingUpdate(
    index_name: option.None,
    provisioned_read_capacity_auto_scaling_update: option.None,
  )
}

pub fn encode_replica_global_secondary_index_auto_scaling_update_struct(
  input: ReplicaGlobalSecondaryIndexAutoScalingUpdate,
) -> json.Json {
  let pairs = []
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.provisioned_read_capacity_auto_scaling_update {
    option.Some(v) -> [
      #(
        "ProvisionedReadCapacityAutoScalingUpdate",
        encode_auto_scaling_settings_update_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_replica_global_secondary_index_auto_scaling_update_struct_top(
  input: ReplicaGlobalSecondaryIndexAutoScalingUpdate,
) -> json.Json {
  let pairs = []
  let pairs = case input.index_name {
    option.Some(v) -> [#("IndexName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.provisioned_read_capacity_auto_scaling_update {
    option.Some(v) -> [
      #(
        "ProvisionedReadCapacityAutoScalingUpdate",
        encode_auto_scaling_settings_update_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_replica_global_secondary_index_auto_scaling_update_struct() -> decode.Decoder(
  ReplicaGlobalSecondaryIndexAutoScalingUpdate,
) {
  use <- decode.recursive
  use index_name <- decode.optional_field(
    "IndexName",
    option.None,
    decode.optional(decode.string),
  )
  use provisioned_read_capacity_auto_scaling_update <- decode.optional_field(
    "ProvisionedReadCapacityAutoScalingUpdate",
    option.None,
    decode.optional(decode_auto_scaling_settings_update_struct()),
  )
  decode.success(ReplicaGlobalSecondaryIndexAutoScalingUpdate(
    index_name: index_name,
    provisioned_read_capacity_auto_scaling_update: provisioned_read_capacity_auto_scaling_update,
  ))
}

pub type UpdateTableReplicaAutoScalingOutput {
  UpdateTableReplicaAutoScalingOutput(
    table_auto_scaling_description: option.Option(TableAutoScalingDescription),
  )
}

pub fn update_table_replica_auto_scaling_output_default() -> UpdateTableReplicaAutoScalingOutput {
  UpdateTableReplicaAutoScalingOutput(
    table_auto_scaling_description: option.None,
  )
}

pub fn encode_update_table_replica_auto_scaling_output_struct(
  input: UpdateTableReplicaAutoScalingOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.table_auto_scaling_description {
    option.Some(v) -> [
      #(
        "TableAutoScalingDescription",
        encode_table_auto_scaling_description_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_update_table_replica_auto_scaling_output_struct_top(
  input: UpdateTableReplicaAutoScalingOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.table_auto_scaling_description {
    option.Some(v) -> [
      #(
        "TableAutoScalingDescription",
        encode_table_auto_scaling_description_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_table_replica_auto_scaling_output_struct() -> decode.Decoder(
  UpdateTableReplicaAutoScalingOutput,
) {
  use <- decode.recursive
  use table_auto_scaling_description <- decode.optional_field(
    "TableAutoScalingDescription",
    option.None,
    decode.optional(decode_table_auto_scaling_description_struct()),
  )
  decode.success(UpdateTableReplicaAutoScalingOutput(
    table_auto_scaling_description: table_auto_scaling_description,
  ))
}

pub type UpdateTimeToLiveInput {
  UpdateTimeToLiveInput(
    table_name: option.Option(String),
    time_to_live_specification: option.Option(TimeToLiveSpecification),
  )
}

pub fn update_time_to_live_input_default() -> UpdateTimeToLiveInput {
  UpdateTimeToLiveInput(
    table_name: option.None,
    time_to_live_specification: option.None,
  )
}

pub fn encode_update_time_to_live_input_struct(
  input: UpdateTimeToLiveInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.time_to_live_specification {
    option.Some(v) -> [
      #("TimeToLiveSpecification", encode_time_to_live_specification_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_update_time_to_live_input_struct_top(
  input: UpdateTimeToLiveInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.table_name {
    option.Some(v) -> [#("TableName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.time_to_live_specification {
    option.Some(v) -> [
      #("TimeToLiveSpecification", encode_time_to_live_specification_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_time_to_live_input_struct() -> decode.Decoder(
  UpdateTimeToLiveInput,
) {
  use <- decode.recursive
  use table_name <- decode.optional_field(
    "TableName",
    option.None,
    decode.optional(decode.string),
  )
  use time_to_live_specification <- decode.optional_field(
    "TimeToLiveSpecification",
    option.None,
    decode.optional(decode_time_to_live_specification_struct()),
  )
  decode.success(UpdateTimeToLiveInput(
    table_name: table_name,
    time_to_live_specification: time_to_live_specification,
  ))
}

pub type TimeToLiveSpecification {
  TimeToLiveSpecification(
    attribute_name: option.Option(String),
    enabled: option.Option(Bool),
  )
}

pub fn time_to_live_specification_default() -> TimeToLiveSpecification {
  TimeToLiveSpecification(attribute_name: option.None, enabled: option.None)
}

pub fn encode_time_to_live_specification_struct(
  input: TimeToLiveSpecification,
) -> json.Json {
  let pairs = []
  let pairs = case input.attribute_name {
    option.Some(v) -> [#("AttributeName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.enabled {
    option.Some(v) -> [#("Enabled", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_time_to_live_specification_struct_top(
  input: TimeToLiveSpecification,
) -> json.Json {
  let pairs = []
  let pairs = case input.attribute_name {
    option.Some(v) -> [#("AttributeName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.enabled {
    option.Some(v) -> [#("Enabled", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_time_to_live_specification_struct() -> decode.Decoder(
  TimeToLiveSpecification,
) {
  use <- decode.recursive
  use attribute_name <- decode.optional_field(
    "AttributeName",
    option.None,
    decode.optional(decode.string),
  )
  use enabled <- decode.optional_field(
    "Enabled",
    option.None,
    decode.optional(decode.bool),
  )
  decode.success(TimeToLiveSpecification(
    attribute_name: attribute_name,
    enabled: enabled,
  ))
}

pub type UpdateTimeToLiveOutput {
  UpdateTimeToLiveOutput(
    time_to_live_specification: option.Option(TimeToLiveSpecification),
  )
}

pub fn update_time_to_live_output_default() -> UpdateTimeToLiveOutput {
  UpdateTimeToLiveOutput(time_to_live_specification: option.None)
}

pub fn encode_update_time_to_live_output_struct(
  input: UpdateTimeToLiveOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.time_to_live_specification {
    option.Some(v) -> [
      #("TimeToLiveSpecification", encode_time_to_live_specification_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn encode_update_time_to_live_output_struct_top(
  input: UpdateTimeToLiveOutput,
) -> json.Json {
  let pairs = []
  let pairs = case input.time_to_live_specification {
    option.Some(v) -> [
      #("TimeToLiveSpecification", encode_time_to_live_specification_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_time_to_live_output_struct() -> decode.Decoder(
  UpdateTimeToLiveOutput,
) {
  use <- decode.recursive
  use time_to_live_specification <- decode.optional_field(
    "TimeToLiveSpecification",
    option.None,
    decode.optional(decode_time_to_live_specification_struct()),
  )
  decode.success(UpdateTimeToLiveOutput(
    time_to_live_specification: time_to_live_specification,
  ))
}

pub fn encode_batch_execute_statement_input(
  input: BatchExecuteStatementInput,
) -> String {
  json.to_string(encode_batch_execute_statement_input_struct_top(input))
}

pub fn decode_batch_execute_statement_output(
  body: String,
) -> Result(BatchExecuteStatementOutput, String) {
  case json.parse(body, decode_batch_execute_statement_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_batch_execute_statement_request(
  input: BatchExecuteStatementInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_batch_execute_statement_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.BatchExecuteStatement"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_batch_execute_statement_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(BatchExecuteStatementOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_batch_execute_statement_output("{}")
        _ -> decode_batch_execute_statement_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type BatchExecuteStatementError {
  BatchExecuteStatementErrorInternalServerError(value: InternalServerError)
  BatchExecuteStatementErrorRequestLimitExceeded(value: RequestLimitExceeded)
  BatchExecuteStatementErrorThrottlingException(value: ThrottlingException)
  BatchExecuteStatementErrorTransport(reason: String)
  BatchExecuteStatementErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn batch_execute_statement_error_decoders() {
  [
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(BatchExecuteStatementErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("RequestLimitExceeded", fn(body) {
      case json.parse(body, decode_request_limit_exceeded_struct()) {
        Ok(v) -> Ok(BatchExecuteStatementErrorRequestLimitExceeded(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ThrottlingException", fn(body) {
      case json.parse(body, decode_throttling_exception_struct()) {
        Ok(v) -> Ok(BatchExecuteStatementErrorThrottlingException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_batch_execute_statement_error(
  err: runtime.ClientError,
) -> BatchExecuteStatementError {
  runtime.translate_service_error(
    err,
    batch_execute_statement_error_decoders(),
    fn(reason) { BatchExecuteStatementErrorTransport(reason: reason) },
    fn(et, s, body) {
      BatchExecuteStatementErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_batch_get_item_input(input: BatchGetItemInput) -> String {
  json.to_string(encode_batch_get_item_input_struct_top(input))
}

pub fn decode_batch_get_item_output(
  body: String,
) -> Result(BatchGetItemOutput, String) {
  case json.parse(body, decode_batch_get_item_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_batch_get_item_request(
  input: BatchGetItemInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_batch_get_item_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.BatchGetItem"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_batch_get_item_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(BatchGetItemOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_batch_get_item_output("{}")
        _ -> decode_batch_get_item_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type BatchGetItemError {
  BatchGetItemErrorInternalServerError(value: InternalServerError)
  BatchGetItemErrorInvalidEndpointException(value: InvalidEndpointException)
  BatchGetItemErrorProvisionedThroughputExceededException(
    value: ProvisionedThroughputExceededException,
  )
  BatchGetItemErrorRequestLimitExceeded(value: RequestLimitExceeded)
  BatchGetItemErrorResourceNotFoundException(value: ResourceNotFoundException)
  BatchGetItemErrorThrottlingException(value: ThrottlingException)
  BatchGetItemErrorTransport(reason: String)
  BatchGetItemErrorUnknown(error_type: String, status: Int, body: String)
}

fn batch_get_item_error_decoders() {
  [
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(BatchGetItemErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) -> Ok(BatchGetItemErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ProvisionedThroughputExceededException", fn(body) {
      case
        json.parse(
          body,
          decode_provisioned_throughput_exceeded_exception_struct(),
        )
      {
        Ok(v) ->
          Ok(BatchGetItemErrorProvisionedThroughputExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("RequestLimitExceeded", fn(body) {
      case json.parse(body, decode_request_limit_exceeded_struct()) {
        Ok(v) -> Ok(BatchGetItemErrorRequestLimitExceeded(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceNotFoundException", fn(body) {
      case json.parse(body, decode_resource_not_found_exception_struct()) {
        Ok(v) -> Ok(BatchGetItemErrorResourceNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ThrottlingException", fn(body) {
      case json.parse(body, decode_throttling_exception_struct()) {
        Ok(v) -> Ok(BatchGetItemErrorThrottlingException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_batch_get_item_error(
  err: runtime.ClientError,
) -> BatchGetItemError {
  runtime.translate_service_error(
    err,
    batch_get_item_error_decoders(),
    fn(reason) { BatchGetItemErrorTransport(reason: reason) },
    fn(et, s, body) {
      BatchGetItemErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_batch_write_item_input(input: BatchWriteItemInput) -> String {
  json.to_string(encode_batch_write_item_input_struct_top(input))
}

pub fn decode_batch_write_item_output(
  body: String,
) -> Result(BatchWriteItemOutput, String) {
  case json.parse(body, decode_batch_write_item_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_batch_write_item_request(
  input: BatchWriteItemInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_batch_write_item_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.BatchWriteItem"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_batch_write_item_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(BatchWriteItemOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_batch_write_item_output("{}")
        _ -> decode_batch_write_item_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type BatchWriteItemError {
  BatchWriteItemErrorInternalServerError(value: InternalServerError)
  BatchWriteItemErrorInvalidEndpointException(value: InvalidEndpointException)
  BatchWriteItemErrorItemCollectionSizeLimitExceededException(
    value: ItemCollectionSizeLimitExceededException,
  )
  BatchWriteItemErrorProvisionedThroughputExceededException(
    value: ProvisionedThroughputExceededException,
  )
  BatchWriteItemErrorReplicatedWriteConflictException(
    value: ReplicatedWriteConflictException,
  )
  BatchWriteItemErrorRequestLimitExceeded(value: RequestLimitExceeded)
  BatchWriteItemErrorResourceNotFoundException(value: ResourceNotFoundException)
  BatchWriteItemErrorThrottlingException(value: ThrottlingException)
  BatchWriteItemErrorTransport(reason: String)
  BatchWriteItemErrorUnknown(error_type: String, status: Int, body: String)
}

fn batch_write_item_error_decoders() {
  [
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(BatchWriteItemErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) -> Ok(BatchWriteItemErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ItemCollectionSizeLimitExceededException", fn(body) {
      case
        json.parse(
          body,
          decode_item_collection_size_limit_exceeded_exception_struct(),
        )
      {
        Ok(v) ->
          Ok(BatchWriteItemErrorItemCollectionSizeLimitExceededException(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
    #("ProvisionedThroughputExceededException", fn(body) {
      case
        json.parse(
          body,
          decode_provisioned_throughput_exceeded_exception_struct(),
        )
      {
        Ok(v) ->
          Ok(BatchWriteItemErrorProvisionedThroughputExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ReplicatedWriteConflictException", fn(body) {
      case
        json.parse(body, decode_replicated_write_conflict_exception_struct())
      {
        Ok(v) ->
          Ok(BatchWriteItemErrorReplicatedWriteConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("RequestLimitExceeded", fn(body) {
      case json.parse(body, decode_request_limit_exceeded_struct()) {
        Ok(v) -> Ok(BatchWriteItemErrorRequestLimitExceeded(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceNotFoundException", fn(body) {
      case json.parse(body, decode_resource_not_found_exception_struct()) {
        Ok(v) -> Ok(BatchWriteItemErrorResourceNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ThrottlingException", fn(body) {
      case json.parse(body, decode_throttling_exception_struct()) {
        Ok(v) -> Ok(BatchWriteItemErrorThrottlingException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_batch_write_item_error(
  err: runtime.ClientError,
) -> BatchWriteItemError {
  runtime.translate_service_error(
    err,
    batch_write_item_error_decoders(),
    fn(reason) { BatchWriteItemErrorTransport(reason: reason) },
    fn(et, s, body) {
      BatchWriteItemErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_create_backup_input(input: CreateBackupInput) -> String {
  json.to_string(encode_create_backup_input_struct_top(input))
}

pub fn decode_create_backup_output(
  body: String,
) -> Result(CreateBackupOutput, String) {
  case json.parse(body, decode_create_backup_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_create_backup_request(
  input: CreateBackupInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_create_backup_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.CreateBackup"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_create_backup_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(CreateBackupOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_create_backup_output("{}")
        _ -> decode_create_backup_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type CreateBackupError {
  CreateBackupErrorBackupInUseException(value: BackupInUseException)
  CreateBackupErrorContinuousBackupsUnavailableException(
    value: ContinuousBackupsUnavailableException,
  )
  CreateBackupErrorInternalServerError(value: InternalServerError)
  CreateBackupErrorInvalidEndpointException(value: InvalidEndpointException)
  CreateBackupErrorLimitExceededException(value: LimitExceededException)
  CreateBackupErrorTableInUseException(value: TableInUseException)
  CreateBackupErrorTableNotFoundException(value: TableNotFoundException)
  CreateBackupErrorTransport(reason: String)
  CreateBackupErrorUnknown(error_type: String, status: Int, body: String)
}

fn create_backup_error_decoders() {
  [
    #("BackupInUseException", fn(body) {
      case json.parse(body, decode_backup_in_use_exception_struct()) {
        Ok(v) -> Ok(CreateBackupErrorBackupInUseException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ContinuousBackupsUnavailableException", fn(body) {
      case
        json.parse(
          body,
          decode_continuous_backups_unavailable_exception_struct(),
        )
      {
        Ok(v) ->
          Ok(CreateBackupErrorContinuousBackupsUnavailableException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(CreateBackupErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) -> Ok(CreateBackupErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(CreateBackupErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TableInUseException", fn(body) {
      case json.parse(body, decode_table_in_use_exception_struct()) {
        Ok(v) -> Ok(CreateBackupErrorTableInUseException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TableNotFoundException", fn(body) {
      case json.parse(body, decode_table_not_found_exception_struct()) {
        Ok(v) -> Ok(CreateBackupErrorTableNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_create_backup_error(
  err: runtime.ClientError,
) -> CreateBackupError {
  runtime.translate_service_error(
    err,
    create_backup_error_decoders(),
    fn(reason) { CreateBackupErrorTransport(reason: reason) },
    fn(et, s, body) {
      CreateBackupErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_create_global_table_input(
  input: CreateGlobalTableInput,
) -> String {
  json.to_string(encode_create_global_table_input_struct_top(input))
}

pub fn decode_create_global_table_output(
  body: String,
) -> Result(CreateGlobalTableOutput, String) {
  case json.parse(body, decode_create_global_table_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_create_global_table_request(
  input: CreateGlobalTableInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_create_global_table_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.CreateGlobalTable"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_create_global_table_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(CreateGlobalTableOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_create_global_table_output("{}")
        _ -> decode_create_global_table_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type CreateGlobalTableError {
  CreateGlobalTableErrorGlobalTableAlreadyExistsException(
    value: GlobalTableAlreadyExistsException,
  )
  CreateGlobalTableErrorInternalServerError(value: InternalServerError)
  CreateGlobalTableErrorInvalidEndpointException(
    value: InvalidEndpointException,
  )
  CreateGlobalTableErrorLimitExceededException(value: LimitExceededException)
  CreateGlobalTableErrorTableNotFoundException(value: TableNotFoundException)
  CreateGlobalTableErrorTransport(reason: String)
  CreateGlobalTableErrorUnknown(error_type: String, status: Int, body: String)
}

fn create_global_table_error_decoders() {
  [
    #("GlobalTableAlreadyExistsException", fn(body) {
      case
        json.parse(body, decode_global_table_already_exists_exception_struct())
      {
        Ok(v) ->
          Ok(CreateGlobalTableErrorGlobalTableAlreadyExistsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(CreateGlobalTableErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) -> Ok(CreateGlobalTableErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(CreateGlobalTableErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TableNotFoundException", fn(body) {
      case json.parse(body, decode_table_not_found_exception_struct()) {
        Ok(v) -> Ok(CreateGlobalTableErrorTableNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_create_global_table_error(
  err: runtime.ClientError,
) -> CreateGlobalTableError {
  runtime.translate_service_error(
    err,
    create_global_table_error_decoders(),
    fn(reason) { CreateGlobalTableErrorTransport(reason: reason) },
    fn(et, s, body) {
      CreateGlobalTableErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_create_table_input(input: CreateTableInput) -> String {
  json.to_string(encode_create_table_input_struct_top(input))
}

pub fn decode_create_table_output(
  body: String,
) -> Result(CreateTableOutput, String) {
  case json.parse(body, decode_create_table_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_create_table_request(
  input: CreateTableInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_create_table_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.CreateTable"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_create_table_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(CreateTableOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_create_table_output("{}")
        _ -> decode_create_table_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type CreateTableError {
  CreateTableErrorInternalServerError(value: InternalServerError)
  CreateTableErrorInvalidEndpointException(value: InvalidEndpointException)
  CreateTableErrorLimitExceededException(value: LimitExceededException)
  CreateTableErrorResourceInUseException(value: ResourceInUseException)
  CreateTableErrorTransport(reason: String)
  CreateTableErrorUnknown(error_type: String, status: Int, body: String)
}

fn create_table_error_decoders() {
  [
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(CreateTableErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) -> Ok(CreateTableErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(CreateTableErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceInUseException", fn(body) {
      case json.parse(body, decode_resource_in_use_exception_struct()) {
        Ok(v) -> Ok(CreateTableErrorResourceInUseException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_create_table_error(err: runtime.ClientError) -> CreateTableError {
  runtime.translate_service_error(
    err,
    create_table_error_decoders(),
    fn(reason) { CreateTableErrorTransport(reason: reason) },
    fn(et, s, body) {
      CreateTableErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_delete_backup_input(input: DeleteBackupInput) -> String {
  json.to_string(encode_delete_backup_input_struct_top(input))
}

pub fn decode_delete_backup_output(
  body: String,
) -> Result(DeleteBackupOutput, String) {
  case json.parse(body, decode_delete_backup_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_delete_backup_request(
  input: DeleteBackupInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_delete_backup_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.DeleteBackup"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_delete_backup_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(DeleteBackupOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_delete_backup_output("{}")
        _ -> decode_delete_backup_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type DeleteBackupError {
  DeleteBackupErrorBackupInUseException(value: BackupInUseException)
  DeleteBackupErrorBackupNotFoundException(value: BackupNotFoundException)
  DeleteBackupErrorInternalServerError(value: InternalServerError)
  DeleteBackupErrorInvalidEndpointException(value: InvalidEndpointException)
  DeleteBackupErrorLimitExceededException(value: LimitExceededException)
  DeleteBackupErrorTransport(reason: String)
  DeleteBackupErrorUnknown(error_type: String, status: Int, body: String)
}

fn delete_backup_error_decoders() {
  [
    #("BackupInUseException", fn(body) {
      case json.parse(body, decode_backup_in_use_exception_struct()) {
        Ok(v) -> Ok(DeleteBackupErrorBackupInUseException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("BackupNotFoundException", fn(body) {
      case json.parse(body, decode_backup_not_found_exception_struct()) {
        Ok(v) -> Ok(DeleteBackupErrorBackupNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(DeleteBackupErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) -> Ok(DeleteBackupErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(DeleteBackupErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_delete_backup_error(
  err: runtime.ClientError,
) -> DeleteBackupError {
  runtime.translate_service_error(
    err,
    delete_backup_error_decoders(),
    fn(reason) { DeleteBackupErrorTransport(reason: reason) },
    fn(et, s, body) {
      DeleteBackupErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_delete_item_input(input: DeleteItemInput) -> String {
  json.to_string(encode_delete_item_input_struct_top(input))
}

pub fn decode_delete_item_output(
  body: String,
) -> Result(DeleteItemOutput, String) {
  case json.parse(body, decode_delete_item_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_delete_item_request(
  input: DeleteItemInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_delete_item_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.DeleteItem"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_delete_item_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(DeleteItemOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_delete_item_output("{}")
        _ -> decode_delete_item_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type DeleteItemError {
  DeleteItemErrorConditionalCheckFailedException(
    value: ConditionalCheckFailedException,
  )
  DeleteItemErrorInternalServerError(value: InternalServerError)
  DeleteItemErrorInvalidEndpointException(value: InvalidEndpointException)
  DeleteItemErrorItemCollectionSizeLimitExceededException(
    value: ItemCollectionSizeLimitExceededException,
  )
  DeleteItemErrorProvisionedThroughputExceededException(
    value: ProvisionedThroughputExceededException,
  )
  DeleteItemErrorReplicatedWriteConflictException(
    value: ReplicatedWriteConflictException,
  )
  DeleteItemErrorRequestLimitExceeded(value: RequestLimitExceeded)
  DeleteItemErrorResourceNotFoundException(value: ResourceNotFoundException)
  DeleteItemErrorThrottlingException(value: ThrottlingException)
  DeleteItemErrorTransactionConflictException(
    value: TransactionConflictException,
  )
  DeleteItemErrorTransport(reason: String)
  DeleteItemErrorUnknown(error_type: String, status: Int, body: String)
}

fn delete_item_error_decoders() {
  [
    #("ConditionalCheckFailedException", fn(body) {
      case
        json.parse(body, decode_conditional_check_failed_exception_struct())
      {
        Ok(v) -> Ok(DeleteItemErrorConditionalCheckFailedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(DeleteItemErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) -> Ok(DeleteItemErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ItemCollectionSizeLimitExceededException", fn(body) {
      case
        json.parse(
          body,
          decode_item_collection_size_limit_exceeded_exception_struct(),
        )
      {
        Ok(v) ->
          Ok(DeleteItemErrorItemCollectionSizeLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ProvisionedThroughputExceededException", fn(body) {
      case
        json.parse(
          body,
          decode_provisioned_throughput_exceeded_exception_struct(),
        )
      {
        Ok(v) ->
          Ok(DeleteItemErrorProvisionedThroughputExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ReplicatedWriteConflictException", fn(body) {
      case
        json.parse(body, decode_replicated_write_conflict_exception_struct())
      {
        Ok(v) -> Ok(DeleteItemErrorReplicatedWriteConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("RequestLimitExceeded", fn(body) {
      case json.parse(body, decode_request_limit_exceeded_struct()) {
        Ok(v) -> Ok(DeleteItemErrorRequestLimitExceeded(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceNotFoundException", fn(body) {
      case json.parse(body, decode_resource_not_found_exception_struct()) {
        Ok(v) -> Ok(DeleteItemErrorResourceNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ThrottlingException", fn(body) {
      case json.parse(body, decode_throttling_exception_struct()) {
        Ok(v) -> Ok(DeleteItemErrorThrottlingException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TransactionConflictException", fn(body) {
      case json.parse(body, decode_transaction_conflict_exception_struct()) {
        Ok(v) -> Ok(DeleteItemErrorTransactionConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_delete_item_error(err: runtime.ClientError) -> DeleteItemError {
  runtime.translate_service_error(
    err,
    delete_item_error_decoders(),
    fn(reason) { DeleteItemErrorTransport(reason: reason) },
    fn(et, s, body) {
      DeleteItemErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_delete_resource_policy_input(
  input: DeleteResourcePolicyInput,
) -> String {
  json.to_string(encode_delete_resource_policy_input_struct_top(input))
}

pub fn decode_delete_resource_policy_output(
  body: String,
) -> Result(DeleteResourcePolicyOutput, String) {
  case json.parse(body, decode_delete_resource_policy_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_delete_resource_policy_request(
  input: DeleteResourcePolicyInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_delete_resource_policy_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.DeleteResourcePolicy"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_delete_resource_policy_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(DeleteResourcePolicyOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_delete_resource_policy_output("{}")
        _ -> decode_delete_resource_policy_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type DeleteResourcePolicyError {
  DeleteResourcePolicyErrorInternalServerError(value: InternalServerError)
  DeleteResourcePolicyErrorInvalidEndpointException(
    value: InvalidEndpointException,
  )
  DeleteResourcePolicyErrorLimitExceededException(value: LimitExceededException)
  DeleteResourcePolicyErrorPolicyNotFoundException(
    value: PolicyNotFoundException,
  )
  DeleteResourcePolicyErrorResourceInUseException(value: ResourceInUseException)
  DeleteResourcePolicyErrorResourceNotFoundException(
    value: ResourceNotFoundException,
  )
  DeleteResourcePolicyErrorTransport(reason: String)
  DeleteResourcePolicyErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn delete_resource_policy_error_decoders() {
  [
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(DeleteResourcePolicyErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) -> Ok(DeleteResourcePolicyErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(DeleteResourcePolicyErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("PolicyNotFoundException", fn(body) {
      case json.parse(body, decode_policy_not_found_exception_struct()) {
        Ok(v) -> Ok(DeleteResourcePolicyErrorPolicyNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceInUseException", fn(body) {
      case json.parse(body, decode_resource_in_use_exception_struct()) {
        Ok(v) -> Ok(DeleteResourcePolicyErrorResourceInUseException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceNotFoundException", fn(body) {
      case json.parse(body, decode_resource_not_found_exception_struct()) {
        Ok(v) ->
          Ok(DeleteResourcePolicyErrorResourceNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_delete_resource_policy_error(
  err: runtime.ClientError,
) -> DeleteResourcePolicyError {
  runtime.translate_service_error(
    err,
    delete_resource_policy_error_decoders(),
    fn(reason) { DeleteResourcePolicyErrorTransport(reason: reason) },
    fn(et, s, body) {
      DeleteResourcePolicyErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_delete_table_input(input: DeleteTableInput) -> String {
  json.to_string(encode_delete_table_input_struct_top(input))
}

pub fn decode_delete_table_output(
  body: String,
) -> Result(DeleteTableOutput, String) {
  case json.parse(body, decode_delete_table_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_delete_table_request(
  input: DeleteTableInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_delete_table_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.DeleteTable"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_delete_table_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(DeleteTableOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_delete_table_output("{}")
        _ -> decode_delete_table_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type DeleteTableError {
  DeleteTableErrorInternalServerError(value: InternalServerError)
  DeleteTableErrorInvalidEndpointException(value: InvalidEndpointException)
  DeleteTableErrorLimitExceededException(value: LimitExceededException)
  DeleteTableErrorResourceInUseException(value: ResourceInUseException)
  DeleteTableErrorResourceNotFoundException(value: ResourceNotFoundException)
  DeleteTableErrorTransport(reason: String)
  DeleteTableErrorUnknown(error_type: String, status: Int, body: String)
}

fn delete_table_error_decoders() {
  [
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(DeleteTableErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) -> Ok(DeleteTableErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(DeleteTableErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceInUseException", fn(body) {
      case json.parse(body, decode_resource_in_use_exception_struct()) {
        Ok(v) -> Ok(DeleteTableErrorResourceInUseException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceNotFoundException", fn(body) {
      case json.parse(body, decode_resource_not_found_exception_struct()) {
        Ok(v) -> Ok(DeleteTableErrorResourceNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_delete_table_error(err: runtime.ClientError) -> DeleteTableError {
  runtime.translate_service_error(
    err,
    delete_table_error_decoders(),
    fn(reason) { DeleteTableErrorTransport(reason: reason) },
    fn(et, s, body) {
      DeleteTableErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_describe_backup_input(input: DescribeBackupInput) -> String {
  json.to_string(encode_describe_backup_input_struct_top(input))
}

pub fn decode_describe_backup_output(
  body: String,
) -> Result(DescribeBackupOutput, String) {
  case json.parse(body, decode_describe_backup_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_describe_backup_request(
  input: DescribeBackupInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_describe_backup_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.DescribeBackup"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_describe_backup_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(DescribeBackupOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_describe_backup_output("{}")
        _ -> decode_describe_backup_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type DescribeBackupError {
  DescribeBackupErrorBackupNotFoundException(value: BackupNotFoundException)
  DescribeBackupErrorInternalServerError(value: InternalServerError)
  DescribeBackupErrorInvalidEndpointException(value: InvalidEndpointException)
  DescribeBackupErrorTransport(reason: String)
  DescribeBackupErrorUnknown(error_type: String, status: Int, body: String)
}

fn describe_backup_error_decoders() {
  [
    #("BackupNotFoundException", fn(body) {
      case json.parse(body, decode_backup_not_found_exception_struct()) {
        Ok(v) -> Ok(DescribeBackupErrorBackupNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(DescribeBackupErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) -> Ok(DescribeBackupErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_describe_backup_error(
  err: runtime.ClientError,
) -> DescribeBackupError {
  runtime.translate_service_error(
    err,
    describe_backup_error_decoders(),
    fn(reason) { DescribeBackupErrorTransport(reason: reason) },
    fn(et, s, body) {
      DescribeBackupErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_describe_continuous_backups_input(
  input: DescribeContinuousBackupsInput,
) -> String {
  json.to_string(encode_describe_continuous_backups_input_struct_top(input))
}

pub fn decode_describe_continuous_backups_output(
  body: String,
) -> Result(DescribeContinuousBackupsOutput, String) {
  case json.parse(body, decode_describe_continuous_backups_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_describe_continuous_backups_request(
  input: DescribeContinuousBackupsInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_describe_continuous_backups_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.DescribeContinuousBackups"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_describe_continuous_backups_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(DescribeContinuousBackupsOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_describe_continuous_backups_output("{}")
        _ -> decode_describe_continuous_backups_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type DescribeContinuousBackupsError {
  DescribeContinuousBackupsErrorInternalServerError(value: InternalServerError)
  DescribeContinuousBackupsErrorInvalidEndpointException(
    value: InvalidEndpointException,
  )
  DescribeContinuousBackupsErrorTableNotFoundException(
    value: TableNotFoundException,
  )
  DescribeContinuousBackupsErrorTransport(reason: String)
  DescribeContinuousBackupsErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn describe_continuous_backups_error_decoders() {
  [
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(DescribeContinuousBackupsErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) ->
          Ok(DescribeContinuousBackupsErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TableNotFoundException", fn(body) {
      case json.parse(body, decode_table_not_found_exception_struct()) {
        Ok(v) ->
          Ok(DescribeContinuousBackupsErrorTableNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_describe_continuous_backups_error(
  err: runtime.ClientError,
) -> DescribeContinuousBackupsError {
  runtime.translate_service_error(
    err,
    describe_continuous_backups_error_decoders(),
    fn(reason) { DescribeContinuousBackupsErrorTransport(reason: reason) },
    fn(et, s, body) {
      DescribeContinuousBackupsErrorUnknown(
        error_type: et,
        status: s,
        body: body,
      )
    },
  )
}

pub fn encode_describe_contributor_insights_input(
  input: DescribeContributorInsightsInput,
) -> String {
  json.to_string(encode_describe_contributor_insights_input_struct_top(input))
}

pub fn decode_describe_contributor_insights_output(
  body: String,
) -> Result(DescribeContributorInsightsOutput, String) {
  case json.parse(body, decode_describe_contributor_insights_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_describe_contributor_insights_request(
  input: DescribeContributorInsightsInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_describe_contributor_insights_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.DescribeContributorInsights"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_describe_contributor_insights_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(DescribeContributorInsightsOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_describe_contributor_insights_output("{}")
        _ -> decode_describe_contributor_insights_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type DescribeContributorInsightsError {
  DescribeContributorInsightsErrorInternalServerError(
    value: InternalServerError,
  )
  DescribeContributorInsightsErrorResourceNotFoundException(
    value: ResourceNotFoundException,
  )
  DescribeContributorInsightsErrorTransport(reason: String)
  DescribeContributorInsightsErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn describe_contributor_insights_error_decoders() {
  [
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) ->
          Ok(DescribeContributorInsightsErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceNotFoundException", fn(body) {
      case json.parse(body, decode_resource_not_found_exception_struct()) {
        Ok(v) ->
          Ok(DescribeContributorInsightsErrorResourceNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_describe_contributor_insights_error(
  err: runtime.ClientError,
) -> DescribeContributorInsightsError {
  runtime.translate_service_error(
    err,
    describe_contributor_insights_error_decoders(),
    fn(reason) { DescribeContributorInsightsErrorTransport(reason: reason) },
    fn(et, s, body) {
      DescribeContributorInsightsErrorUnknown(
        error_type: et,
        status: s,
        body: body,
      )
    },
  )
}

pub fn encode_describe_endpoints_input(
  input: DescribeEndpointsRequest,
) -> String {
  json.to_string(encode_describe_endpoints_request_struct_top(input))
}

pub fn decode_describe_endpoints_output(
  body: String,
) -> Result(DescribeEndpointsResponse, String) {
  case json.parse(body, decode_describe_endpoints_response_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_describe_endpoints_request(
  input: DescribeEndpointsRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_describe_endpoints_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.DescribeEndpoints"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_describe_endpoints_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(DescribeEndpointsResponse, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_describe_endpoints_output("{}")
        _ -> decode_describe_endpoints_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type DescribeEndpointsError {
  DescribeEndpointsErrorTransport(reason: String)
  DescribeEndpointsErrorUnknown(error_type: String, status: Int, body: String)
}

fn describe_endpoints_error_decoders() {
  []
}

fn translate_describe_endpoints_error(
  err: runtime.ClientError,
) -> DescribeEndpointsError {
  runtime.translate_service_error(
    err,
    describe_endpoints_error_decoders(),
    fn(reason) { DescribeEndpointsErrorTransport(reason: reason) },
    fn(et, s, body) {
      DescribeEndpointsErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_describe_export_input(input: DescribeExportInput) -> String {
  json.to_string(encode_describe_export_input_struct_top(input))
}

pub fn decode_describe_export_output(
  body: String,
) -> Result(DescribeExportOutput, String) {
  case json.parse(body, decode_describe_export_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_describe_export_request(
  input: DescribeExportInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_describe_export_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.DescribeExport"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_describe_export_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(DescribeExportOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_describe_export_output("{}")
        _ -> decode_describe_export_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type DescribeExportError {
  DescribeExportErrorExportNotFoundException(value: ExportNotFoundException)
  DescribeExportErrorInternalServerError(value: InternalServerError)
  DescribeExportErrorLimitExceededException(value: LimitExceededException)
  DescribeExportErrorTransport(reason: String)
  DescribeExportErrorUnknown(error_type: String, status: Int, body: String)
}

fn describe_export_error_decoders() {
  [
    #("ExportNotFoundException", fn(body) {
      case json.parse(body, decode_export_not_found_exception_struct()) {
        Ok(v) -> Ok(DescribeExportErrorExportNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(DescribeExportErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(DescribeExportErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_describe_export_error(
  err: runtime.ClientError,
) -> DescribeExportError {
  runtime.translate_service_error(
    err,
    describe_export_error_decoders(),
    fn(reason) { DescribeExportErrorTransport(reason: reason) },
    fn(et, s, body) {
      DescribeExportErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_describe_global_table_input(
  input: DescribeGlobalTableInput,
) -> String {
  json.to_string(encode_describe_global_table_input_struct_top(input))
}

pub fn decode_describe_global_table_output(
  body: String,
) -> Result(DescribeGlobalTableOutput, String) {
  case json.parse(body, decode_describe_global_table_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_describe_global_table_request(
  input: DescribeGlobalTableInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_describe_global_table_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.DescribeGlobalTable"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_describe_global_table_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(DescribeGlobalTableOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_describe_global_table_output("{}")
        _ -> decode_describe_global_table_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type DescribeGlobalTableError {
  DescribeGlobalTableErrorGlobalTableNotFoundException(
    value: GlobalTableNotFoundException,
  )
  DescribeGlobalTableErrorInternalServerError(value: InternalServerError)
  DescribeGlobalTableErrorInvalidEndpointException(
    value: InvalidEndpointException,
  )
  DescribeGlobalTableErrorTransport(reason: String)
  DescribeGlobalTableErrorUnknown(error_type: String, status: Int, body: String)
}

fn describe_global_table_error_decoders() {
  [
    #("GlobalTableNotFoundException", fn(body) {
      case json.parse(body, decode_global_table_not_found_exception_struct()) {
        Ok(v) ->
          Ok(DescribeGlobalTableErrorGlobalTableNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(DescribeGlobalTableErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) -> Ok(DescribeGlobalTableErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_describe_global_table_error(
  err: runtime.ClientError,
) -> DescribeGlobalTableError {
  runtime.translate_service_error(
    err,
    describe_global_table_error_decoders(),
    fn(reason) { DescribeGlobalTableErrorTransport(reason: reason) },
    fn(et, s, body) {
      DescribeGlobalTableErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_describe_global_table_settings_input(
  input: DescribeGlobalTableSettingsInput,
) -> String {
  json.to_string(encode_describe_global_table_settings_input_struct_top(input))
}

pub fn decode_describe_global_table_settings_output(
  body: String,
) -> Result(DescribeGlobalTableSettingsOutput, String) {
  case json.parse(body, decode_describe_global_table_settings_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_describe_global_table_settings_request(
  input: DescribeGlobalTableSettingsInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_describe_global_table_settings_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.DescribeGlobalTableSettings"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_describe_global_table_settings_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(DescribeGlobalTableSettingsOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_describe_global_table_settings_output("{}")
        _ -> decode_describe_global_table_settings_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type DescribeGlobalTableSettingsError {
  DescribeGlobalTableSettingsErrorGlobalTableNotFoundException(
    value: GlobalTableNotFoundException,
  )
  DescribeGlobalTableSettingsErrorInternalServerError(
    value: InternalServerError,
  )
  DescribeGlobalTableSettingsErrorInvalidEndpointException(
    value: InvalidEndpointException,
  )
  DescribeGlobalTableSettingsErrorTransport(reason: String)
  DescribeGlobalTableSettingsErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn describe_global_table_settings_error_decoders() {
  [
    #("GlobalTableNotFoundException", fn(body) {
      case json.parse(body, decode_global_table_not_found_exception_struct()) {
        Ok(v) ->
          Ok(DescribeGlobalTableSettingsErrorGlobalTableNotFoundException(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) ->
          Ok(DescribeGlobalTableSettingsErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) ->
          Ok(DescribeGlobalTableSettingsErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_describe_global_table_settings_error(
  err: runtime.ClientError,
) -> DescribeGlobalTableSettingsError {
  runtime.translate_service_error(
    err,
    describe_global_table_settings_error_decoders(),
    fn(reason) { DescribeGlobalTableSettingsErrorTransport(reason: reason) },
    fn(et, s, body) {
      DescribeGlobalTableSettingsErrorUnknown(
        error_type: et,
        status: s,
        body: body,
      )
    },
  )
}

pub fn encode_describe_import_input(input: DescribeImportInput) -> String {
  json.to_string(encode_describe_import_input_struct_top(input))
}

pub fn decode_describe_import_output(
  body: String,
) -> Result(DescribeImportOutput, String) {
  case json.parse(body, decode_describe_import_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_describe_import_request(
  input: DescribeImportInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_describe_import_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.DescribeImport"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_describe_import_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(DescribeImportOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_describe_import_output("{}")
        _ -> decode_describe_import_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type DescribeImportError {
  DescribeImportErrorImportNotFoundException(value: ImportNotFoundException)
  DescribeImportErrorTransport(reason: String)
  DescribeImportErrorUnknown(error_type: String, status: Int, body: String)
}

fn describe_import_error_decoders() {
  [
    #("ImportNotFoundException", fn(body) {
      case json.parse(body, decode_import_not_found_exception_struct()) {
        Ok(v) -> Ok(DescribeImportErrorImportNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_describe_import_error(
  err: runtime.ClientError,
) -> DescribeImportError {
  runtime.translate_service_error(
    err,
    describe_import_error_decoders(),
    fn(reason) { DescribeImportErrorTransport(reason: reason) },
    fn(et, s, body) {
      DescribeImportErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_describe_kinesis_streaming_destination_input(
  input: DescribeKinesisStreamingDestinationInput,
) -> String {
  json.to_string(encode_describe_kinesis_streaming_destination_input_struct_top(
    input,
  ))
}

pub fn decode_describe_kinesis_streaming_destination_output(
  body: String,
) -> Result(DescribeKinesisStreamingDestinationOutput, String) {
  case
    json.parse(
      body,
      decode_describe_kinesis_streaming_destination_output_struct(),
    )
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_describe_kinesis_streaming_destination_request(
  input: DescribeKinesisStreamingDestinationInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_describe_kinesis_streaming_destination_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.DescribeKinesisStreamingDestination"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_describe_kinesis_streaming_destination_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(DescribeKinesisStreamingDestinationOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_describe_kinesis_streaming_destination_output("{}")
        _ -> decode_describe_kinesis_streaming_destination_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type DescribeKinesisStreamingDestinationError {
  DescribeKinesisStreamingDestinationErrorInternalServerError(
    value: InternalServerError,
  )
  DescribeKinesisStreamingDestinationErrorInvalidEndpointException(
    value: InvalidEndpointException,
  )
  DescribeKinesisStreamingDestinationErrorResourceNotFoundException(
    value: ResourceNotFoundException,
  )
  DescribeKinesisStreamingDestinationErrorTransport(reason: String)
  DescribeKinesisStreamingDestinationErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn describe_kinesis_streaming_destination_error_decoders() {
  [
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) ->
          Ok(DescribeKinesisStreamingDestinationErrorInternalServerError(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) ->
          Ok(DescribeKinesisStreamingDestinationErrorInvalidEndpointException(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceNotFoundException", fn(body) {
      case json.parse(body, decode_resource_not_found_exception_struct()) {
        Ok(v) ->
          Ok(DescribeKinesisStreamingDestinationErrorResourceNotFoundException(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_describe_kinesis_streaming_destination_error(
  err: runtime.ClientError,
) -> DescribeKinesisStreamingDestinationError {
  runtime.translate_service_error(
    err,
    describe_kinesis_streaming_destination_error_decoders(),
    fn(reason) {
      DescribeKinesisStreamingDestinationErrorTransport(reason: reason)
    },
    fn(et, s, body) {
      DescribeKinesisStreamingDestinationErrorUnknown(
        error_type: et,
        status: s,
        body: body,
      )
    },
  )
}

pub fn encode_describe_limits_input(input: DescribeLimitsInput) -> String {
  json.to_string(encode_describe_limits_input_struct_top(input))
}

pub fn decode_describe_limits_output(
  body: String,
) -> Result(DescribeLimitsOutput, String) {
  case json.parse(body, decode_describe_limits_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_describe_limits_request(
  input: DescribeLimitsInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_describe_limits_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.DescribeLimits"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_describe_limits_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(DescribeLimitsOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_describe_limits_output("{}")
        _ -> decode_describe_limits_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type DescribeLimitsError {
  DescribeLimitsErrorInternalServerError(value: InternalServerError)
  DescribeLimitsErrorInvalidEndpointException(value: InvalidEndpointException)
  DescribeLimitsErrorTransport(reason: String)
  DescribeLimitsErrorUnknown(error_type: String, status: Int, body: String)
}

fn describe_limits_error_decoders() {
  [
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(DescribeLimitsErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) -> Ok(DescribeLimitsErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_describe_limits_error(
  err: runtime.ClientError,
) -> DescribeLimitsError {
  runtime.translate_service_error(
    err,
    describe_limits_error_decoders(),
    fn(reason) { DescribeLimitsErrorTransport(reason: reason) },
    fn(et, s, body) {
      DescribeLimitsErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_describe_table_input(input: DescribeTableInput) -> String {
  json.to_string(encode_describe_table_input_struct_top(input))
}

pub fn decode_describe_table_output(
  body: String,
) -> Result(DescribeTableOutput, String) {
  case json.parse(body, decode_describe_table_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_describe_table_request(
  input: DescribeTableInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_describe_table_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.DescribeTable"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_describe_table_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(DescribeTableOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_describe_table_output("{}")
        _ -> decode_describe_table_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type DescribeTableError {
  DescribeTableErrorInternalServerError(value: InternalServerError)
  DescribeTableErrorInvalidEndpointException(value: InvalidEndpointException)
  DescribeTableErrorResourceNotFoundException(value: ResourceNotFoundException)
  DescribeTableErrorTransport(reason: String)
  DescribeTableErrorUnknown(error_type: String, status: Int, body: String)
}

fn describe_table_error_decoders() {
  [
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(DescribeTableErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) -> Ok(DescribeTableErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceNotFoundException", fn(body) {
      case json.parse(body, decode_resource_not_found_exception_struct()) {
        Ok(v) -> Ok(DescribeTableErrorResourceNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_describe_table_error(
  err: runtime.ClientError,
) -> DescribeTableError {
  runtime.translate_service_error(
    err,
    describe_table_error_decoders(),
    fn(reason) { DescribeTableErrorTransport(reason: reason) },
    fn(et, s, body) {
      DescribeTableErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_describe_table_replica_auto_scaling_input(
  input: DescribeTableReplicaAutoScalingInput,
) -> String {
  json.to_string(encode_describe_table_replica_auto_scaling_input_struct_top(
    input,
  ))
}

pub fn decode_describe_table_replica_auto_scaling_output(
  body: String,
) -> Result(DescribeTableReplicaAutoScalingOutput, String) {
  case
    json.parse(body, decode_describe_table_replica_auto_scaling_output_struct())
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_describe_table_replica_auto_scaling_request(
  input: DescribeTableReplicaAutoScalingInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_describe_table_replica_auto_scaling_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.DescribeTableReplicaAutoScaling"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_describe_table_replica_auto_scaling_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(DescribeTableReplicaAutoScalingOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_describe_table_replica_auto_scaling_output("{}")
        _ -> decode_describe_table_replica_auto_scaling_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type DescribeTableReplicaAutoScalingError {
  DescribeTableReplicaAutoScalingErrorInternalServerError(
    value: InternalServerError,
  )
  DescribeTableReplicaAutoScalingErrorResourceNotFoundException(
    value: ResourceNotFoundException,
  )
  DescribeTableReplicaAutoScalingErrorTransport(reason: String)
  DescribeTableReplicaAutoScalingErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn describe_table_replica_auto_scaling_error_decoders() {
  [
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) ->
          Ok(DescribeTableReplicaAutoScalingErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceNotFoundException", fn(body) {
      case json.parse(body, decode_resource_not_found_exception_struct()) {
        Ok(v) ->
          Ok(DescribeTableReplicaAutoScalingErrorResourceNotFoundException(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_describe_table_replica_auto_scaling_error(
  err: runtime.ClientError,
) -> DescribeTableReplicaAutoScalingError {
  runtime.translate_service_error(
    err,
    describe_table_replica_auto_scaling_error_decoders(),
    fn(reason) { DescribeTableReplicaAutoScalingErrorTransport(reason: reason) },
    fn(et, s, body) {
      DescribeTableReplicaAutoScalingErrorUnknown(
        error_type: et,
        status: s,
        body: body,
      )
    },
  )
}

pub fn encode_describe_time_to_live_input(
  input: DescribeTimeToLiveInput,
) -> String {
  json.to_string(encode_describe_time_to_live_input_struct_top(input))
}

pub fn decode_describe_time_to_live_output(
  body: String,
) -> Result(DescribeTimeToLiveOutput, String) {
  case json.parse(body, decode_describe_time_to_live_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_describe_time_to_live_request(
  input: DescribeTimeToLiveInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_describe_time_to_live_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.DescribeTimeToLive"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_describe_time_to_live_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(DescribeTimeToLiveOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_describe_time_to_live_output("{}")
        _ -> decode_describe_time_to_live_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type DescribeTimeToLiveError {
  DescribeTimeToLiveErrorInternalServerError(value: InternalServerError)
  DescribeTimeToLiveErrorInvalidEndpointException(
    value: InvalidEndpointException,
  )
  DescribeTimeToLiveErrorResourceNotFoundException(
    value: ResourceNotFoundException,
  )
  DescribeTimeToLiveErrorTransport(reason: String)
  DescribeTimeToLiveErrorUnknown(error_type: String, status: Int, body: String)
}

fn describe_time_to_live_error_decoders() {
  [
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(DescribeTimeToLiveErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) -> Ok(DescribeTimeToLiveErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceNotFoundException", fn(body) {
      case json.parse(body, decode_resource_not_found_exception_struct()) {
        Ok(v) -> Ok(DescribeTimeToLiveErrorResourceNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_describe_time_to_live_error(
  err: runtime.ClientError,
) -> DescribeTimeToLiveError {
  runtime.translate_service_error(
    err,
    describe_time_to_live_error_decoders(),
    fn(reason) { DescribeTimeToLiveErrorTransport(reason: reason) },
    fn(et, s, body) {
      DescribeTimeToLiveErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_disable_kinesis_streaming_destination_input(
  input: KinesisStreamingDestinationInput,
) -> String {
  json.to_string(encode_kinesis_streaming_destination_input_struct_top(input))
}

pub fn decode_disable_kinesis_streaming_destination_output(
  body: String,
) -> Result(KinesisStreamingDestinationOutput, String) {
  case json.parse(body, decode_kinesis_streaming_destination_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_disable_kinesis_streaming_destination_request(
  input: KinesisStreamingDestinationInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_disable_kinesis_streaming_destination_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.DisableKinesisStreamingDestination"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_disable_kinesis_streaming_destination_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(KinesisStreamingDestinationOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_disable_kinesis_streaming_destination_output("{}")
        _ -> decode_disable_kinesis_streaming_destination_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type DisableKinesisStreamingDestinationError {
  DisableKinesisStreamingDestinationErrorInternalServerError(
    value: InternalServerError,
  )
  DisableKinesisStreamingDestinationErrorInvalidEndpointException(
    value: InvalidEndpointException,
  )
  DisableKinesisStreamingDestinationErrorLimitExceededException(
    value: LimitExceededException,
  )
  DisableKinesisStreamingDestinationErrorResourceInUseException(
    value: ResourceInUseException,
  )
  DisableKinesisStreamingDestinationErrorResourceNotFoundException(
    value: ResourceNotFoundException,
  )
  DisableKinesisStreamingDestinationErrorTransport(reason: String)
  DisableKinesisStreamingDestinationErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn disable_kinesis_streaming_destination_error_decoders() {
  [
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) ->
          Ok(DisableKinesisStreamingDestinationErrorInternalServerError(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) ->
          Ok(DisableKinesisStreamingDestinationErrorInvalidEndpointException(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) ->
          Ok(DisableKinesisStreamingDestinationErrorLimitExceededException(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceInUseException", fn(body) {
      case json.parse(body, decode_resource_in_use_exception_struct()) {
        Ok(v) ->
          Ok(DisableKinesisStreamingDestinationErrorResourceInUseException(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceNotFoundException", fn(body) {
      case json.parse(body, decode_resource_not_found_exception_struct()) {
        Ok(v) ->
          Ok(DisableKinesisStreamingDestinationErrorResourceNotFoundException(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_disable_kinesis_streaming_destination_error(
  err: runtime.ClientError,
) -> DisableKinesisStreamingDestinationError {
  runtime.translate_service_error(
    err,
    disable_kinesis_streaming_destination_error_decoders(),
    fn(reason) {
      DisableKinesisStreamingDestinationErrorTransport(reason: reason)
    },
    fn(et, s, body) {
      DisableKinesisStreamingDestinationErrorUnknown(
        error_type: et,
        status: s,
        body: body,
      )
    },
  )
}

pub fn encode_enable_kinesis_streaming_destination_input(
  input: KinesisStreamingDestinationInput,
) -> String {
  json.to_string(encode_kinesis_streaming_destination_input_struct_top(input))
}

pub fn decode_enable_kinesis_streaming_destination_output(
  body: String,
) -> Result(KinesisStreamingDestinationOutput, String) {
  case json.parse(body, decode_kinesis_streaming_destination_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_enable_kinesis_streaming_destination_request(
  input: KinesisStreamingDestinationInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_enable_kinesis_streaming_destination_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.EnableKinesisStreamingDestination"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_enable_kinesis_streaming_destination_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(KinesisStreamingDestinationOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_enable_kinesis_streaming_destination_output("{}")
        _ -> decode_enable_kinesis_streaming_destination_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type EnableKinesisStreamingDestinationError {
  EnableKinesisStreamingDestinationErrorInternalServerError(
    value: InternalServerError,
  )
  EnableKinesisStreamingDestinationErrorInvalidEndpointException(
    value: InvalidEndpointException,
  )
  EnableKinesisStreamingDestinationErrorLimitExceededException(
    value: LimitExceededException,
  )
  EnableKinesisStreamingDestinationErrorResourceInUseException(
    value: ResourceInUseException,
  )
  EnableKinesisStreamingDestinationErrorResourceNotFoundException(
    value: ResourceNotFoundException,
  )
  EnableKinesisStreamingDestinationErrorTransport(reason: String)
  EnableKinesisStreamingDestinationErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn enable_kinesis_streaming_destination_error_decoders() {
  [
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) ->
          Ok(EnableKinesisStreamingDestinationErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) ->
          Ok(EnableKinesisStreamingDestinationErrorInvalidEndpointException(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) ->
          Ok(EnableKinesisStreamingDestinationErrorLimitExceededException(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceInUseException", fn(body) {
      case json.parse(body, decode_resource_in_use_exception_struct()) {
        Ok(v) ->
          Ok(EnableKinesisStreamingDestinationErrorResourceInUseException(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceNotFoundException", fn(body) {
      case json.parse(body, decode_resource_not_found_exception_struct()) {
        Ok(v) ->
          Ok(EnableKinesisStreamingDestinationErrorResourceNotFoundException(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_enable_kinesis_streaming_destination_error(
  err: runtime.ClientError,
) -> EnableKinesisStreamingDestinationError {
  runtime.translate_service_error(
    err,
    enable_kinesis_streaming_destination_error_decoders(),
    fn(reason) {
      EnableKinesisStreamingDestinationErrorTransport(reason: reason)
    },
    fn(et, s, body) {
      EnableKinesisStreamingDestinationErrorUnknown(
        error_type: et,
        status: s,
        body: body,
      )
    },
  )
}

pub fn encode_execute_statement_input(input: ExecuteStatementInput) -> String {
  json.to_string(encode_execute_statement_input_struct_top(input))
}

pub fn decode_execute_statement_output(
  body: String,
) -> Result(ExecuteStatementOutput, String) {
  case json.parse(body, decode_execute_statement_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_execute_statement_request(
  input: ExecuteStatementInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_execute_statement_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.ExecuteStatement"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_execute_statement_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(ExecuteStatementOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_execute_statement_output("{}")
        _ -> decode_execute_statement_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type ExecuteStatementError {
  ExecuteStatementErrorConditionalCheckFailedException(
    value: ConditionalCheckFailedException,
  )
  ExecuteStatementErrorDuplicateItemException(value: DuplicateItemException)
  ExecuteStatementErrorInternalServerError(value: InternalServerError)
  ExecuteStatementErrorItemCollectionSizeLimitExceededException(
    value: ItemCollectionSizeLimitExceededException,
  )
  ExecuteStatementErrorProvisionedThroughputExceededException(
    value: ProvisionedThroughputExceededException,
  )
  ExecuteStatementErrorRequestLimitExceeded(value: RequestLimitExceeded)
  ExecuteStatementErrorResourceNotFoundException(
    value: ResourceNotFoundException,
  )
  ExecuteStatementErrorThrottlingException(value: ThrottlingException)
  ExecuteStatementErrorTransactionConflictException(
    value: TransactionConflictException,
  )
  ExecuteStatementErrorTransport(reason: String)
  ExecuteStatementErrorUnknown(error_type: String, status: Int, body: String)
}

fn execute_statement_error_decoders() {
  [
    #("ConditionalCheckFailedException", fn(body) {
      case
        json.parse(body, decode_conditional_check_failed_exception_struct())
      {
        Ok(v) ->
          Ok(ExecuteStatementErrorConditionalCheckFailedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("DuplicateItemException", fn(body) {
      case json.parse(body, decode_duplicate_item_exception_struct()) {
        Ok(v) -> Ok(ExecuteStatementErrorDuplicateItemException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(ExecuteStatementErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ItemCollectionSizeLimitExceededException", fn(body) {
      case
        json.parse(
          body,
          decode_item_collection_size_limit_exceeded_exception_struct(),
        )
      {
        Ok(v) ->
          Ok(ExecuteStatementErrorItemCollectionSizeLimitExceededException(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
    #("ProvisionedThroughputExceededException", fn(body) {
      case
        json.parse(
          body,
          decode_provisioned_throughput_exceeded_exception_struct(),
        )
      {
        Ok(v) ->
          Ok(ExecuteStatementErrorProvisionedThroughputExceededException(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
    #("RequestLimitExceeded", fn(body) {
      case json.parse(body, decode_request_limit_exceeded_struct()) {
        Ok(v) -> Ok(ExecuteStatementErrorRequestLimitExceeded(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceNotFoundException", fn(body) {
      case json.parse(body, decode_resource_not_found_exception_struct()) {
        Ok(v) -> Ok(ExecuteStatementErrorResourceNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ThrottlingException", fn(body) {
      case json.parse(body, decode_throttling_exception_struct()) {
        Ok(v) -> Ok(ExecuteStatementErrorThrottlingException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TransactionConflictException", fn(body) {
      case json.parse(body, decode_transaction_conflict_exception_struct()) {
        Ok(v) -> Ok(ExecuteStatementErrorTransactionConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_execute_statement_error(
  err: runtime.ClientError,
) -> ExecuteStatementError {
  runtime.translate_service_error(
    err,
    execute_statement_error_decoders(),
    fn(reason) { ExecuteStatementErrorTransport(reason: reason) },
    fn(et, s, body) {
      ExecuteStatementErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_execute_transaction_input(
  input: ExecuteTransactionInput,
) -> String {
  json.to_string(encode_execute_transaction_input_struct_top(input))
}

pub fn decode_execute_transaction_output(
  body: String,
) -> Result(ExecuteTransactionOutput, String) {
  case json.parse(body, decode_execute_transaction_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_execute_transaction_request(
  input: ExecuteTransactionInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_execute_transaction_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.ExecuteTransaction"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_execute_transaction_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(ExecuteTransactionOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_execute_transaction_output("{}")
        _ -> decode_execute_transaction_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type ExecuteTransactionError {
  ExecuteTransactionErrorIdempotentParameterMismatchException(
    value: IdempotentParameterMismatchException,
  )
  ExecuteTransactionErrorInternalServerError(value: InternalServerError)
  ExecuteTransactionErrorProvisionedThroughputExceededException(
    value: ProvisionedThroughputExceededException,
  )
  ExecuteTransactionErrorRequestLimitExceeded(value: RequestLimitExceeded)
  ExecuteTransactionErrorResourceNotFoundException(
    value: ResourceNotFoundException,
  )
  ExecuteTransactionErrorThrottlingException(value: ThrottlingException)
  ExecuteTransactionErrorTransactionCanceledException(
    value: TransactionCanceledException,
  )
  ExecuteTransactionErrorTransactionInProgressException(
    value: TransactionInProgressException,
  )
  ExecuteTransactionErrorTransport(reason: String)
  ExecuteTransactionErrorUnknown(error_type: String, status: Int, body: String)
}

fn execute_transaction_error_decoders() {
  [
    #("IdempotentParameterMismatchException", fn(body) {
      case
        json.parse(
          body,
          decode_idempotent_parameter_mismatch_exception_struct(),
        )
      {
        Ok(v) ->
          Ok(ExecuteTransactionErrorIdempotentParameterMismatchException(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(ExecuteTransactionErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ProvisionedThroughputExceededException", fn(body) {
      case
        json.parse(
          body,
          decode_provisioned_throughput_exceeded_exception_struct(),
        )
      {
        Ok(v) ->
          Ok(ExecuteTransactionErrorProvisionedThroughputExceededException(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
    #("RequestLimitExceeded", fn(body) {
      case json.parse(body, decode_request_limit_exceeded_struct()) {
        Ok(v) -> Ok(ExecuteTransactionErrorRequestLimitExceeded(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceNotFoundException", fn(body) {
      case json.parse(body, decode_resource_not_found_exception_struct()) {
        Ok(v) -> Ok(ExecuteTransactionErrorResourceNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ThrottlingException", fn(body) {
      case json.parse(body, decode_throttling_exception_struct()) {
        Ok(v) -> Ok(ExecuteTransactionErrorThrottlingException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TransactionCanceledException", fn(body) {
      case json.parse(body, decode_transaction_canceled_exception_struct()) {
        Ok(v) ->
          Ok(ExecuteTransactionErrorTransactionCanceledException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TransactionInProgressException", fn(body) {
      case json.parse(body, decode_transaction_in_progress_exception_struct()) {
        Ok(v) ->
          Ok(ExecuteTransactionErrorTransactionInProgressException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_execute_transaction_error(
  err: runtime.ClientError,
) -> ExecuteTransactionError {
  runtime.translate_service_error(
    err,
    execute_transaction_error_decoders(),
    fn(reason) { ExecuteTransactionErrorTransport(reason: reason) },
    fn(et, s, body) {
      ExecuteTransactionErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_export_table_to_point_in_time_input(
  input: ExportTableToPointInTimeInput,
) -> String {
  json.to_string(encode_export_table_to_point_in_time_input_struct_top(input))
}

pub fn decode_export_table_to_point_in_time_output(
  body: String,
) -> Result(ExportTableToPointInTimeOutput, String) {
  case json.parse(body, decode_export_table_to_point_in_time_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_export_table_to_point_in_time_request(
  input: ExportTableToPointInTimeInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_export_table_to_point_in_time_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.ExportTableToPointInTime"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_export_table_to_point_in_time_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(ExportTableToPointInTimeOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_export_table_to_point_in_time_output("{}")
        _ -> decode_export_table_to_point_in_time_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type ExportTableToPointInTimeError {
  ExportTableToPointInTimeErrorExportConflictException(
    value: ExportConflictException,
  )
  ExportTableToPointInTimeErrorInternalServerError(value: InternalServerError)
  ExportTableToPointInTimeErrorInvalidExportTimeException(
    value: InvalidExportTimeException,
  )
  ExportTableToPointInTimeErrorLimitExceededException(
    value: LimitExceededException,
  )
  ExportTableToPointInTimeErrorPointInTimeRecoveryUnavailableException(
    value: PointInTimeRecoveryUnavailableException,
  )
  ExportTableToPointInTimeErrorTableNotFoundException(
    value: TableNotFoundException,
  )
  ExportTableToPointInTimeErrorTransport(reason: String)
  ExportTableToPointInTimeErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn export_table_to_point_in_time_error_decoders() {
  [
    #("ExportConflictException", fn(body) {
      case json.parse(body, decode_export_conflict_exception_struct()) {
        Ok(v) ->
          Ok(ExportTableToPointInTimeErrorExportConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(ExportTableToPointInTimeErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidExportTimeException", fn(body) {
      case json.parse(body, decode_invalid_export_time_exception_struct()) {
        Ok(v) ->
          Ok(ExportTableToPointInTimeErrorInvalidExportTimeException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) ->
          Ok(ExportTableToPointInTimeErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("PointInTimeRecoveryUnavailableException", fn(body) {
      case
        json.parse(
          body,
          decode_point_in_time_recovery_unavailable_exception_struct(),
        )
      {
        Ok(v) ->
          Ok(
            ExportTableToPointInTimeErrorPointInTimeRecoveryUnavailableException(
              value: v,
            ),
          )
        Error(_) -> Error(Nil)
      }
    }),
    #("TableNotFoundException", fn(body) {
      case json.parse(body, decode_table_not_found_exception_struct()) {
        Ok(v) ->
          Ok(ExportTableToPointInTimeErrorTableNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_export_table_to_point_in_time_error(
  err: runtime.ClientError,
) -> ExportTableToPointInTimeError {
  runtime.translate_service_error(
    err,
    export_table_to_point_in_time_error_decoders(),
    fn(reason) { ExportTableToPointInTimeErrorTransport(reason: reason) },
    fn(et, s, body) {
      ExportTableToPointInTimeErrorUnknown(
        error_type: et,
        status: s,
        body: body,
      )
    },
  )
}

pub fn encode_get_item_input(input: GetItemInput) -> String {
  json.to_string(encode_get_item_input_struct_top(input))
}

pub fn decode_get_item_output(body: String) -> Result(GetItemOutput, String) {
  case json.parse(body, decode_get_item_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_get_item_request(
  input: GetItemInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_get_item_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.GetItem"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_get_item_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(GetItemOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_item_output("{}")
        _ -> decode_get_item_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type GetItemError {
  GetItemErrorInternalServerError(value: InternalServerError)
  GetItemErrorInvalidEndpointException(value: InvalidEndpointException)
  GetItemErrorProvisionedThroughputExceededException(
    value: ProvisionedThroughputExceededException,
  )
  GetItemErrorRequestLimitExceeded(value: RequestLimitExceeded)
  GetItemErrorResourceNotFoundException(value: ResourceNotFoundException)
  GetItemErrorThrottlingException(value: ThrottlingException)
  GetItemErrorTransport(reason: String)
  GetItemErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_item_error_decoders() {
  [
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(GetItemErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) -> Ok(GetItemErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ProvisionedThroughputExceededException", fn(body) {
      case
        json.parse(
          body,
          decode_provisioned_throughput_exceeded_exception_struct(),
        )
      {
        Ok(v) ->
          Ok(GetItemErrorProvisionedThroughputExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("RequestLimitExceeded", fn(body) {
      case json.parse(body, decode_request_limit_exceeded_struct()) {
        Ok(v) -> Ok(GetItemErrorRequestLimitExceeded(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceNotFoundException", fn(body) {
      case json.parse(body, decode_resource_not_found_exception_struct()) {
        Ok(v) -> Ok(GetItemErrorResourceNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ThrottlingException", fn(body) {
      case json.parse(body, decode_throttling_exception_struct()) {
        Ok(v) -> Ok(GetItemErrorThrottlingException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_item_error(err: runtime.ClientError) -> GetItemError {
  runtime.translate_service_error(
    err,
    get_item_error_decoders(),
    fn(reason) { GetItemErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetItemErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_get_resource_policy_input(
  input: GetResourcePolicyInput,
) -> String {
  json.to_string(encode_get_resource_policy_input_struct_top(input))
}

pub fn decode_get_resource_policy_output(
  body: String,
) -> Result(GetResourcePolicyOutput, String) {
  case json.parse(body, decode_get_resource_policy_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_get_resource_policy_request(
  input: GetResourcePolicyInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_get_resource_policy_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.GetResourcePolicy"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_get_resource_policy_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(GetResourcePolicyOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_resource_policy_output("{}")
        _ -> decode_get_resource_policy_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type GetResourcePolicyError {
  GetResourcePolicyErrorInternalServerError(value: InternalServerError)
  GetResourcePolicyErrorInvalidEndpointException(
    value: InvalidEndpointException,
  )
  GetResourcePolicyErrorPolicyNotFoundException(value: PolicyNotFoundException)
  GetResourcePolicyErrorResourceNotFoundException(
    value: ResourceNotFoundException,
  )
  GetResourcePolicyErrorTransport(reason: String)
  GetResourcePolicyErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_resource_policy_error_decoders() {
  [
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(GetResourcePolicyErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) -> Ok(GetResourcePolicyErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("PolicyNotFoundException", fn(body) {
      case json.parse(body, decode_policy_not_found_exception_struct()) {
        Ok(v) -> Ok(GetResourcePolicyErrorPolicyNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceNotFoundException", fn(body) {
      case json.parse(body, decode_resource_not_found_exception_struct()) {
        Ok(v) -> Ok(GetResourcePolicyErrorResourceNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_resource_policy_error(
  err: runtime.ClientError,
) -> GetResourcePolicyError {
  runtime.translate_service_error(
    err,
    get_resource_policy_error_decoders(),
    fn(reason) { GetResourcePolicyErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetResourcePolicyErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_import_table_input(input: ImportTableInput) -> String {
  json.to_string(encode_import_table_input_struct_top(input))
}

pub fn decode_import_table_output(
  body: String,
) -> Result(ImportTableOutput, String) {
  case json.parse(body, decode_import_table_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_import_table_request(
  input: ImportTableInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_import_table_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.ImportTable"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_import_table_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(ImportTableOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_import_table_output("{}")
        _ -> decode_import_table_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type ImportTableError {
  ImportTableErrorImportConflictException(value: ImportConflictException)
  ImportTableErrorLimitExceededException(value: LimitExceededException)
  ImportTableErrorResourceInUseException(value: ResourceInUseException)
  ImportTableErrorTransport(reason: String)
  ImportTableErrorUnknown(error_type: String, status: Int, body: String)
}

fn import_table_error_decoders() {
  [
    #("ImportConflictException", fn(body) {
      case json.parse(body, decode_import_conflict_exception_struct()) {
        Ok(v) -> Ok(ImportTableErrorImportConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(ImportTableErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceInUseException", fn(body) {
      case json.parse(body, decode_resource_in_use_exception_struct()) {
        Ok(v) -> Ok(ImportTableErrorResourceInUseException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_import_table_error(err: runtime.ClientError) -> ImportTableError {
  runtime.translate_service_error(
    err,
    import_table_error_decoders(),
    fn(reason) { ImportTableErrorTransport(reason: reason) },
    fn(et, s, body) {
      ImportTableErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_list_backups_input(input: ListBackupsInput) -> String {
  json.to_string(encode_list_backups_input_struct_top(input))
}

pub fn decode_list_backups_output(
  body: String,
) -> Result(ListBackupsOutput, String) {
  case json.parse(body, decode_list_backups_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_list_backups_request(
  input: ListBackupsInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_list_backups_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.ListBackups"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_list_backups_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(ListBackupsOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_list_backups_output("{}")
        _ -> decode_list_backups_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type ListBackupsError {
  ListBackupsErrorInternalServerError(value: InternalServerError)
  ListBackupsErrorInvalidEndpointException(value: InvalidEndpointException)
  ListBackupsErrorTransport(reason: String)
  ListBackupsErrorUnknown(error_type: String, status: Int, body: String)
}

fn list_backups_error_decoders() {
  [
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(ListBackupsErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) -> Ok(ListBackupsErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_list_backups_error(err: runtime.ClientError) -> ListBackupsError {
  runtime.translate_service_error(
    err,
    list_backups_error_decoders(),
    fn(reason) { ListBackupsErrorTransport(reason: reason) },
    fn(et, s, body) {
      ListBackupsErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_list_contributor_insights_input(
  input: ListContributorInsightsInput,
) -> String {
  json.to_string(encode_list_contributor_insights_input_struct_top(input))
}

pub fn decode_list_contributor_insights_output(
  body: String,
) -> Result(ListContributorInsightsOutput, String) {
  case json.parse(body, decode_list_contributor_insights_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_list_contributor_insights_request(
  input: ListContributorInsightsInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_list_contributor_insights_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.ListContributorInsights"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_list_contributor_insights_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(ListContributorInsightsOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_list_contributor_insights_output("{}")
        _ -> decode_list_contributor_insights_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type ListContributorInsightsError {
  ListContributorInsightsErrorInternalServerError(value: InternalServerError)
  ListContributorInsightsErrorResourceNotFoundException(
    value: ResourceNotFoundException,
  )
  ListContributorInsightsErrorTransport(reason: String)
  ListContributorInsightsErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn list_contributor_insights_error_decoders() {
  [
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(ListContributorInsightsErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceNotFoundException", fn(body) {
      case json.parse(body, decode_resource_not_found_exception_struct()) {
        Ok(v) ->
          Ok(ListContributorInsightsErrorResourceNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_list_contributor_insights_error(
  err: runtime.ClientError,
) -> ListContributorInsightsError {
  runtime.translate_service_error(
    err,
    list_contributor_insights_error_decoders(),
    fn(reason) { ListContributorInsightsErrorTransport(reason: reason) },
    fn(et, s, body) {
      ListContributorInsightsErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_list_exports_input(input: ListExportsInput) -> String {
  json.to_string(encode_list_exports_input_struct_top(input))
}

pub fn decode_list_exports_output(
  body: String,
) -> Result(ListExportsOutput, String) {
  case json.parse(body, decode_list_exports_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_list_exports_request(
  input: ListExportsInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_list_exports_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.ListExports"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_list_exports_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(ListExportsOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_list_exports_output("{}")
        _ -> decode_list_exports_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type ListExportsError {
  ListExportsErrorInternalServerError(value: InternalServerError)
  ListExportsErrorLimitExceededException(value: LimitExceededException)
  ListExportsErrorTransport(reason: String)
  ListExportsErrorUnknown(error_type: String, status: Int, body: String)
}

fn list_exports_error_decoders() {
  [
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(ListExportsErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(ListExportsErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_list_exports_error(err: runtime.ClientError) -> ListExportsError {
  runtime.translate_service_error(
    err,
    list_exports_error_decoders(),
    fn(reason) { ListExportsErrorTransport(reason: reason) },
    fn(et, s, body) {
      ListExportsErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_list_global_tables_input(input: ListGlobalTablesInput) -> String {
  json.to_string(encode_list_global_tables_input_struct_top(input))
}

pub fn decode_list_global_tables_output(
  body: String,
) -> Result(ListGlobalTablesOutput, String) {
  case json.parse(body, decode_list_global_tables_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_list_global_tables_request(
  input: ListGlobalTablesInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_list_global_tables_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.ListGlobalTables"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_list_global_tables_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(ListGlobalTablesOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_list_global_tables_output("{}")
        _ -> decode_list_global_tables_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type ListGlobalTablesError {
  ListGlobalTablesErrorInternalServerError(value: InternalServerError)
  ListGlobalTablesErrorInvalidEndpointException(value: InvalidEndpointException)
  ListGlobalTablesErrorTransport(reason: String)
  ListGlobalTablesErrorUnknown(error_type: String, status: Int, body: String)
}

fn list_global_tables_error_decoders() {
  [
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(ListGlobalTablesErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) -> Ok(ListGlobalTablesErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_list_global_tables_error(
  err: runtime.ClientError,
) -> ListGlobalTablesError {
  runtime.translate_service_error(
    err,
    list_global_tables_error_decoders(),
    fn(reason) { ListGlobalTablesErrorTransport(reason: reason) },
    fn(et, s, body) {
      ListGlobalTablesErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_list_imports_input(input: ListImportsInput) -> String {
  json.to_string(encode_list_imports_input_struct_top(input))
}

pub fn decode_list_imports_output(
  body: String,
) -> Result(ListImportsOutput, String) {
  case json.parse(body, decode_list_imports_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_list_imports_request(
  input: ListImportsInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_list_imports_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.ListImports"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_list_imports_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(ListImportsOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_list_imports_output("{}")
        _ -> decode_list_imports_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type ListImportsError {
  ListImportsErrorLimitExceededException(value: LimitExceededException)
  ListImportsErrorTransport(reason: String)
  ListImportsErrorUnknown(error_type: String, status: Int, body: String)
}

fn list_imports_error_decoders() {
  [
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(ListImportsErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_list_imports_error(err: runtime.ClientError) -> ListImportsError {
  runtime.translate_service_error(
    err,
    list_imports_error_decoders(),
    fn(reason) { ListImportsErrorTransport(reason: reason) },
    fn(et, s, body) {
      ListImportsErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_list_tables_input(input: ListTablesInput) -> String {
  json.to_string(encode_list_tables_input_struct_top(input))
}

pub fn decode_list_tables_output(
  body: String,
) -> Result(ListTablesOutput, String) {
  case json.parse(body, decode_list_tables_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_list_tables_request(
  input: ListTablesInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_list_tables_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.ListTables"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_list_tables_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(ListTablesOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_list_tables_output("{}")
        _ -> decode_list_tables_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type ListTablesError {
  ListTablesErrorInternalServerError(value: InternalServerError)
  ListTablesErrorInvalidEndpointException(value: InvalidEndpointException)
  ListTablesErrorTransport(reason: String)
  ListTablesErrorUnknown(error_type: String, status: Int, body: String)
}

fn list_tables_error_decoders() {
  [
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(ListTablesErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) -> Ok(ListTablesErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_list_tables_error(err: runtime.ClientError) -> ListTablesError {
  runtime.translate_service_error(
    err,
    list_tables_error_decoders(),
    fn(reason) { ListTablesErrorTransport(reason: reason) },
    fn(et, s, body) {
      ListTablesErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_list_tags_of_resource_input(
  input: ListTagsOfResourceInput,
) -> String {
  json.to_string(encode_list_tags_of_resource_input_struct_top(input))
}

pub fn decode_list_tags_of_resource_output(
  body: String,
) -> Result(ListTagsOfResourceOutput, String) {
  case json.parse(body, decode_list_tags_of_resource_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_list_tags_of_resource_request(
  input: ListTagsOfResourceInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_list_tags_of_resource_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.ListTagsOfResource"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_list_tags_of_resource_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(ListTagsOfResourceOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_list_tags_of_resource_output("{}")
        _ -> decode_list_tags_of_resource_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type ListTagsOfResourceError {
  ListTagsOfResourceErrorInternalServerError(value: InternalServerError)
  ListTagsOfResourceErrorInvalidEndpointException(
    value: InvalidEndpointException,
  )
  ListTagsOfResourceErrorResourceNotFoundException(
    value: ResourceNotFoundException,
  )
  ListTagsOfResourceErrorTransport(reason: String)
  ListTagsOfResourceErrorUnknown(error_type: String, status: Int, body: String)
}

fn list_tags_of_resource_error_decoders() {
  [
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(ListTagsOfResourceErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) -> Ok(ListTagsOfResourceErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceNotFoundException", fn(body) {
      case json.parse(body, decode_resource_not_found_exception_struct()) {
        Ok(v) -> Ok(ListTagsOfResourceErrorResourceNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_list_tags_of_resource_error(
  err: runtime.ClientError,
) -> ListTagsOfResourceError {
  runtime.translate_service_error(
    err,
    list_tags_of_resource_error_decoders(),
    fn(reason) { ListTagsOfResourceErrorTransport(reason: reason) },
    fn(et, s, body) {
      ListTagsOfResourceErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_put_item_input(input: PutItemInput) -> String {
  json.to_string(encode_put_item_input_struct_top(input))
}

pub fn decode_put_item_output(body: String) -> Result(PutItemOutput, String) {
  case json.parse(body, decode_put_item_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_put_item_request(
  input: PutItemInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_put_item_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.PutItem"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_put_item_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(PutItemOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_put_item_output("{}")
        _ -> decode_put_item_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type PutItemError {
  PutItemErrorConditionalCheckFailedException(
    value: ConditionalCheckFailedException,
  )
  PutItemErrorInternalServerError(value: InternalServerError)
  PutItemErrorInvalidEndpointException(value: InvalidEndpointException)
  PutItemErrorItemCollectionSizeLimitExceededException(
    value: ItemCollectionSizeLimitExceededException,
  )
  PutItemErrorProvisionedThroughputExceededException(
    value: ProvisionedThroughputExceededException,
  )
  PutItemErrorReplicatedWriteConflictException(
    value: ReplicatedWriteConflictException,
  )
  PutItemErrorRequestLimitExceeded(value: RequestLimitExceeded)
  PutItemErrorResourceNotFoundException(value: ResourceNotFoundException)
  PutItemErrorThrottlingException(value: ThrottlingException)
  PutItemErrorTransactionConflictException(value: TransactionConflictException)
  PutItemErrorTransport(reason: String)
  PutItemErrorUnknown(error_type: String, status: Int, body: String)
}

fn put_item_error_decoders() {
  [
    #("ConditionalCheckFailedException", fn(body) {
      case
        json.parse(body, decode_conditional_check_failed_exception_struct())
      {
        Ok(v) -> Ok(PutItemErrorConditionalCheckFailedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(PutItemErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) -> Ok(PutItemErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ItemCollectionSizeLimitExceededException", fn(body) {
      case
        json.parse(
          body,
          decode_item_collection_size_limit_exceeded_exception_struct(),
        )
      {
        Ok(v) ->
          Ok(PutItemErrorItemCollectionSizeLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ProvisionedThroughputExceededException", fn(body) {
      case
        json.parse(
          body,
          decode_provisioned_throughput_exceeded_exception_struct(),
        )
      {
        Ok(v) ->
          Ok(PutItemErrorProvisionedThroughputExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ReplicatedWriteConflictException", fn(body) {
      case
        json.parse(body, decode_replicated_write_conflict_exception_struct())
      {
        Ok(v) -> Ok(PutItemErrorReplicatedWriteConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("RequestLimitExceeded", fn(body) {
      case json.parse(body, decode_request_limit_exceeded_struct()) {
        Ok(v) -> Ok(PutItemErrorRequestLimitExceeded(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceNotFoundException", fn(body) {
      case json.parse(body, decode_resource_not_found_exception_struct()) {
        Ok(v) -> Ok(PutItemErrorResourceNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ThrottlingException", fn(body) {
      case json.parse(body, decode_throttling_exception_struct()) {
        Ok(v) -> Ok(PutItemErrorThrottlingException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TransactionConflictException", fn(body) {
      case json.parse(body, decode_transaction_conflict_exception_struct()) {
        Ok(v) -> Ok(PutItemErrorTransactionConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_put_item_error(err: runtime.ClientError) -> PutItemError {
  runtime.translate_service_error(
    err,
    put_item_error_decoders(),
    fn(reason) { PutItemErrorTransport(reason: reason) },
    fn(et, s, body) {
      PutItemErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_put_resource_policy_input(
  input: PutResourcePolicyInput,
) -> String {
  json.to_string(encode_put_resource_policy_input_struct_top(input))
}

pub fn decode_put_resource_policy_output(
  body: String,
) -> Result(PutResourcePolicyOutput, String) {
  case json.parse(body, decode_put_resource_policy_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_put_resource_policy_request(
  input: PutResourcePolicyInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_put_resource_policy_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.PutResourcePolicy"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_put_resource_policy_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(PutResourcePolicyOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_put_resource_policy_output("{}")
        _ -> decode_put_resource_policy_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type PutResourcePolicyError {
  PutResourcePolicyErrorInternalServerError(value: InternalServerError)
  PutResourcePolicyErrorInvalidEndpointException(
    value: InvalidEndpointException,
  )
  PutResourcePolicyErrorLimitExceededException(value: LimitExceededException)
  PutResourcePolicyErrorPolicyNotFoundException(value: PolicyNotFoundException)
  PutResourcePolicyErrorResourceInUseException(value: ResourceInUseException)
  PutResourcePolicyErrorResourceNotFoundException(
    value: ResourceNotFoundException,
  )
  PutResourcePolicyErrorTransport(reason: String)
  PutResourcePolicyErrorUnknown(error_type: String, status: Int, body: String)
}

fn put_resource_policy_error_decoders() {
  [
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(PutResourcePolicyErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) -> Ok(PutResourcePolicyErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(PutResourcePolicyErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("PolicyNotFoundException", fn(body) {
      case json.parse(body, decode_policy_not_found_exception_struct()) {
        Ok(v) -> Ok(PutResourcePolicyErrorPolicyNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceInUseException", fn(body) {
      case json.parse(body, decode_resource_in_use_exception_struct()) {
        Ok(v) -> Ok(PutResourcePolicyErrorResourceInUseException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceNotFoundException", fn(body) {
      case json.parse(body, decode_resource_not_found_exception_struct()) {
        Ok(v) -> Ok(PutResourcePolicyErrorResourceNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_put_resource_policy_error(
  err: runtime.ClientError,
) -> PutResourcePolicyError {
  runtime.translate_service_error(
    err,
    put_resource_policy_error_decoders(),
    fn(reason) { PutResourcePolicyErrorTransport(reason: reason) },
    fn(et, s, body) {
      PutResourcePolicyErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_query_input(input: QueryInput) -> String {
  json.to_string(encode_query_input_struct_top(input))
}

pub fn decode_query_output(body: String) -> Result(QueryOutput, String) {
  case json.parse(body, decode_query_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_query_request(
  input: QueryInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_query_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.Query"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_query_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(QueryOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_query_output("{}")
        _ -> decode_query_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type QueryError {
  QueryErrorInternalServerError(value: InternalServerError)
  QueryErrorInvalidEndpointException(value: InvalidEndpointException)
  QueryErrorProvisionedThroughputExceededException(
    value: ProvisionedThroughputExceededException,
  )
  QueryErrorRequestLimitExceeded(value: RequestLimitExceeded)
  QueryErrorResourceNotFoundException(value: ResourceNotFoundException)
  QueryErrorThrottlingException(value: ThrottlingException)
  QueryErrorTransport(reason: String)
  QueryErrorUnknown(error_type: String, status: Int, body: String)
}

fn query_error_decoders() {
  [
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(QueryErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) -> Ok(QueryErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ProvisionedThroughputExceededException", fn(body) {
      case
        json.parse(
          body,
          decode_provisioned_throughput_exceeded_exception_struct(),
        )
      {
        Ok(v) -> Ok(QueryErrorProvisionedThroughputExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("RequestLimitExceeded", fn(body) {
      case json.parse(body, decode_request_limit_exceeded_struct()) {
        Ok(v) -> Ok(QueryErrorRequestLimitExceeded(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceNotFoundException", fn(body) {
      case json.parse(body, decode_resource_not_found_exception_struct()) {
        Ok(v) -> Ok(QueryErrorResourceNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ThrottlingException", fn(body) {
      case json.parse(body, decode_throttling_exception_struct()) {
        Ok(v) -> Ok(QueryErrorThrottlingException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_query_error(err: runtime.ClientError) -> QueryError {
  runtime.translate_service_error(
    err,
    query_error_decoders(),
    fn(reason) { QueryErrorTransport(reason: reason) },
    fn(et, s, body) { QueryErrorUnknown(error_type: et, status: s, body: body) },
  )
}

pub fn encode_restore_table_from_backup_input(
  input: RestoreTableFromBackupInput,
) -> String {
  json.to_string(encode_restore_table_from_backup_input_struct_top(input))
}

pub fn decode_restore_table_from_backup_output(
  body: String,
) -> Result(RestoreTableFromBackupOutput, String) {
  case json.parse(body, decode_restore_table_from_backup_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_restore_table_from_backup_request(
  input: RestoreTableFromBackupInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_restore_table_from_backup_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.RestoreTableFromBackup"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_restore_table_from_backup_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(RestoreTableFromBackupOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_restore_table_from_backup_output("{}")
        _ -> decode_restore_table_from_backup_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type RestoreTableFromBackupError {
  RestoreTableFromBackupErrorBackupInUseException(value: BackupInUseException)
  RestoreTableFromBackupErrorBackupNotFoundException(
    value: BackupNotFoundException,
  )
  RestoreTableFromBackupErrorInternalServerError(value: InternalServerError)
  RestoreTableFromBackupErrorInvalidEndpointException(
    value: InvalidEndpointException,
  )
  RestoreTableFromBackupErrorLimitExceededException(
    value: LimitExceededException,
  )
  RestoreTableFromBackupErrorTableAlreadyExistsException(
    value: TableAlreadyExistsException,
  )
  RestoreTableFromBackupErrorTableInUseException(value: TableInUseException)
  RestoreTableFromBackupErrorTransport(reason: String)
  RestoreTableFromBackupErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn restore_table_from_backup_error_decoders() {
  [
    #("BackupInUseException", fn(body) {
      case json.parse(body, decode_backup_in_use_exception_struct()) {
        Ok(v) -> Ok(RestoreTableFromBackupErrorBackupInUseException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("BackupNotFoundException", fn(body) {
      case json.parse(body, decode_backup_not_found_exception_struct()) {
        Ok(v) ->
          Ok(RestoreTableFromBackupErrorBackupNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(RestoreTableFromBackupErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) ->
          Ok(RestoreTableFromBackupErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(RestoreTableFromBackupErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TableAlreadyExistsException", fn(body) {
      case json.parse(body, decode_table_already_exists_exception_struct()) {
        Ok(v) ->
          Ok(RestoreTableFromBackupErrorTableAlreadyExistsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TableInUseException", fn(body) {
      case json.parse(body, decode_table_in_use_exception_struct()) {
        Ok(v) -> Ok(RestoreTableFromBackupErrorTableInUseException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_restore_table_from_backup_error(
  err: runtime.ClientError,
) -> RestoreTableFromBackupError {
  runtime.translate_service_error(
    err,
    restore_table_from_backup_error_decoders(),
    fn(reason) { RestoreTableFromBackupErrorTransport(reason: reason) },
    fn(et, s, body) {
      RestoreTableFromBackupErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_restore_table_to_point_in_time_input(
  input: RestoreTableToPointInTimeInput,
) -> String {
  json.to_string(encode_restore_table_to_point_in_time_input_struct_top(input))
}

pub fn decode_restore_table_to_point_in_time_output(
  body: String,
) -> Result(RestoreTableToPointInTimeOutput, String) {
  case json.parse(body, decode_restore_table_to_point_in_time_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_restore_table_to_point_in_time_request(
  input: RestoreTableToPointInTimeInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_restore_table_to_point_in_time_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.RestoreTableToPointInTime"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_restore_table_to_point_in_time_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(RestoreTableToPointInTimeOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_restore_table_to_point_in_time_output("{}")
        _ -> decode_restore_table_to_point_in_time_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type RestoreTableToPointInTimeError {
  RestoreTableToPointInTimeErrorInternalServerError(value: InternalServerError)
  RestoreTableToPointInTimeErrorInvalidEndpointException(
    value: InvalidEndpointException,
  )
  RestoreTableToPointInTimeErrorInvalidRestoreTimeException(
    value: InvalidRestoreTimeException,
  )
  RestoreTableToPointInTimeErrorLimitExceededException(
    value: LimitExceededException,
  )
  RestoreTableToPointInTimeErrorPointInTimeRecoveryUnavailableException(
    value: PointInTimeRecoveryUnavailableException,
  )
  RestoreTableToPointInTimeErrorTableAlreadyExistsException(
    value: TableAlreadyExistsException,
  )
  RestoreTableToPointInTimeErrorTableInUseException(value: TableInUseException)
  RestoreTableToPointInTimeErrorTableNotFoundException(
    value: TableNotFoundException,
  )
  RestoreTableToPointInTimeErrorTransport(reason: String)
  RestoreTableToPointInTimeErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn restore_table_to_point_in_time_error_decoders() {
  [
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(RestoreTableToPointInTimeErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) ->
          Ok(RestoreTableToPointInTimeErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidRestoreTimeException", fn(body) {
      case json.parse(body, decode_invalid_restore_time_exception_struct()) {
        Ok(v) ->
          Ok(RestoreTableToPointInTimeErrorInvalidRestoreTimeException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) ->
          Ok(RestoreTableToPointInTimeErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("PointInTimeRecoveryUnavailableException", fn(body) {
      case
        json.parse(
          body,
          decode_point_in_time_recovery_unavailable_exception_struct(),
        )
      {
        Ok(v) ->
          Ok(
            RestoreTableToPointInTimeErrorPointInTimeRecoveryUnavailableException(
              value: v,
            ),
          )
        Error(_) -> Error(Nil)
      }
    }),
    #("TableAlreadyExistsException", fn(body) {
      case json.parse(body, decode_table_already_exists_exception_struct()) {
        Ok(v) ->
          Ok(RestoreTableToPointInTimeErrorTableAlreadyExistsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TableInUseException", fn(body) {
      case json.parse(body, decode_table_in_use_exception_struct()) {
        Ok(v) -> Ok(RestoreTableToPointInTimeErrorTableInUseException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TableNotFoundException", fn(body) {
      case json.parse(body, decode_table_not_found_exception_struct()) {
        Ok(v) ->
          Ok(RestoreTableToPointInTimeErrorTableNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_restore_table_to_point_in_time_error(
  err: runtime.ClientError,
) -> RestoreTableToPointInTimeError {
  runtime.translate_service_error(
    err,
    restore_table_to_point_in_time_error_decoders(),
    fn(reason) { RestoreTableToPointInTimeErrorTransport(reason: reason) },
    fn(et, s, body) {
      RestoreTableToPointInTimeErrorUnknown(
        error_type: et,
        status: s,
        body: body,
      )
    },
  )
}

pub fn encode_scan_input(input: ScanInput) -> String {
  json.to_string(encode_scan_input_struct_top(input))
}

pub fn decode_scan_output(body: String) -> Result(ScanOutput, String) {
  case json.parse(body, decode_scan_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_scan_request(
  input: ScanInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_scan_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.Scan"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_scan_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(ScanOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_scan_output("{}")
        _ -> decode_scan_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type ScanError {
  ScanErrorInternalServerError(value: InternalServerError)
  ScanErrorInvalidEndpointException(value: InvalidEndpointException)
  ScanErrorProvisionedThroughputExceededException(
    value: ProvisionedThroughputExceededException,
  )
  ScanErrorRequestLimitExceeded(value: RequestLimitExceeded)
  ScanErrorResourceNotFoundException(value: ResourceNotFoundException)
  ScanErrorThrottlingException(value: ThrottlingException)
  ScanErrorTransport(reason: String)
  ScanErrorUnknown(error_type: String, status: Int, body: String)
}

fn scan_error_decoders() {
  [
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(ScanErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) -> Ok(ScanErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ProvisionedThroughputExceededException", fn(body) {
      case
        json.parse(
          body,
          decode_provisioned_throughput_exceeded_exception_struct(),
        )
      {
        Ok(v) -> Ok(ScanErrorProvisionedThroughputExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("RequestLimitExceeded", fn(body) {
      case json.parse(body, decode_request_limit_exceeded_struct()) {
        Ok(v) -> Ok(ScanErrorRequestLimitExceeded(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceNotFoundException", fn(body) {
      case json.parse(body, decode_resource_not_found_exception_struct()) {
        Ok(v) -> Ok(ScanErrorResourceNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ThrottlingException", fn(body) {
      case json.parse(body, decode_throttling_exception_struct()) {
        Ok(v) -> Ok(ScanErrorThrottlingException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_scan_error(err: runtime.ClientError) -> ScanError {
  runtime.translate_service_error(
    err,
    scan_error_decoders(),
    fn(reason) { ScanErrorTransport(reason: reason) },
    fn(et, s, body) { ScanErrorUnknown(error_type: et, status: s, body: body) },
  )
}

pub type TagResourceOutput {
  TagResourceOutput
}

pub fn tag_resource_output_default() -> TagResourceOutput {
  TagResourceOutput
}

pub fn decode_tag_resource_output_struct() -> decode.Decoder(TagResourceOutput) {
  decode.success(TagResourceOutput)
}

pub fn encode_tag_resource_input(input: TagResourceInput) -> String {
  json.to_string(encode_tag_resource_input_struct_top(input))
}

pub fn decode_tag_resource_output(
  body: String,
) -> Result(TagResourceOutput, String) {
  case json.parse(body, decode_tag_resource_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_tag_resource_request(
  input: TagResourceInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_tag_resource_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.TagResource"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_tag_resource_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(TagResourceOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_tag_resource_output("{}")
        _ -> decode_tag_resource_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type TagResourceError {
  TagResourceErrorInternalServerError(value: InternalServerError)
  TagResourceErrorInvalidEndpointException(value: InvalidEndpointException)
  TagResourceErrorLimitExceededException(value: LimitExceededException)
  TagResourceErrorResourceInUseException(value: ResourceInUseException)
  TagResourceErrorResourceNotFoundException(value: ResourceNotFoundException)
  TagResourceErrorTransport(reason: String)
  TagResourceErrorUnknown(error_type: String, status: Int, body: String)
}

fn tag_resource_error_decoders() {
  [
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(TagResourceErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) -> Ok(TagResourceErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(TagResourceErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceInUseException", fn(body) {
      case json.parse(body, decode_resource_in_use_exception_struct()) {
        Ok(v) -> Ok(TagResourceErrorResourceInUseException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceNotFoundException", fn(body) {
      case json.parse(body, decode_resource_not_found_exception_struct()) {
        Ok(v) -> Ok(TagResourceErrorResourceNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_tag_resource_error(err: runtime.ClientError) -> TagResourceError {
  runtime.translate_service_error(
    err,
    tag_resource_error_decoders(),
    fn(reason) { TagResourceErrorTransport(reason: reason) },
    fn(et, s, body) {
      TagResourceErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_transact_get_items_input(input: TransactGetItemsInput) -> String {
  json.to_string(encode_transact_get_items_input_struct_top(input))
}

pub fn decode_transact_get_items_output(
  body: String,
) -> Result(TransactGetItemsOutput, String) {
  case json.parse(body, decode_transact_get_items_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_transact_get_items_request(
  input: TransactGetItemsInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_transact_get_items_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.TransactGetItems"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_transact_get_items_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(TransactGetItemsOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_transact_get_items_output("{}")
        _ -> decode_transact_get_items_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type TransactGetItemsError {
  TransactGetItemsErrorInternalServerError(value: InternalServerError)
  TransactGetItemsErrorInvalidEndpointException(value: InvalidEndpointException)
  TransactGetItemsErrorProvisionedThroughputExceededException(
    value: ProvisionedThroughputExceededException,
  )
  TransactGetItemsErrorRequestLimitExceeded(value: RequestLimitExceeded)
  TransactGetItemsErrorResourceNotFoundException(
    value: ResourceNotFoundException,
  )
  TransactGetItemsErrorThrottlingException(value: ThrottlingException)
  TransactGetItemsErrorTransactionCanceledException(
    value: TransactionCanceledException,
  )
  TransactGetItemsErrorTransport(reason: String)
  TransactGetItemsErrorUnknown(error_type: String, status: Int, body: String)
}

fn transact_get_items_error_decoders() {
  [
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(TransactGetItemsErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) -> Ok(TransactGetItemsErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ProvisionedThroughputExceededException", fn(body) {
      case
        json.parse(
          body,
          decode_provisioned_throughput_exceeded_exception_struct(),
        )
      {
        Ok(v) ->
          Ok(TransactGetItemsErrorProvisionedThroughputExceededException(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
    #("RequestLimitExceeded", fn(body) {
      case json.parse(body, decode_request_limit_exceeded_struct()) {
        Ok(v) -> Ok(TransactGetItemsErrorRequestLimitExceeded(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceNotFoundException", fn(body) {
      case json.parse(body, decode_resource_not_found_exception_struct()) {
        Ok(v) -> Ok(TransactGetItemsErrorResourceNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ThrottlingException", fn(body) {
      case json.parse(body, decode_throttling_exception_struct()) {
        Ok(v) -> Ok(TransactGetItemsErrorThrottlingException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TransactionCanceledException", fn(body) {
      case json.parse(body, decode_transaction_canceled_exception_struct()) {
        Ok(v) -> Ok(TransactGetItemsErrorTransactionCanceledException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_transact_get_items_error(
  err: runtime.ClientError,
) -> TransactGetItemsError {
  runtime.translate_service_error(
    err,
    transact_get_items_error_decoders(),
    fn(reason) { TransactGetItemsErrorTransport(reason: reason) },
    fn(et, s, body) {
      TransactGetItemsErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_transact_write_items_input(
  input: TransactWriteItemsInput,
) -> String {
  json.to_string(encode_transact_write_items_input_struct_top(input))
}

pub fn decode_transact_write_items_output(
  body: String,
) -> Result(TransactWriteItemsOutput, String) {
  case json.parse(body, decode_transact_write_items_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_transact_write_items_request(
  input: TransactWriteItemsInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_transact_write_items_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.TransactWriteItems"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_transact_write_items_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(TransactWriteItemsOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_transact_write_items_output("{}")
        _ -> decode_transact_write_items_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type TransactWriteItemsError {
  TransactWriteItemsErrorIdempotentParameterMismatchException(
    value: IdempotentParameterMismatchException,
  )
  TransactWriteItemsErrorInternalServerError(value: InternalServerError)
  TransactWriteItemsErrorInvalidEndpointException(
    value: InvalidEndpointException,
  )
  TransactWriteItemsErrorProvisionedThroughputExceededException(
    value: ProvisionedThroughputExceededException,
  )
  TransactWriteItemsErrorRequestLimitExceeded(value: RequestLimitExceeded)
  TransactWriteItemsErrorResourceNotFoundException(
    value: ResourceNotFoundException,
  )
  TransactWriteItemsErrorThrottlingException(value: ThrottlingException)
  TransactWriteItemsErrorTransactionCanceledException(
    value: TransactionCanceledException,
  )
  TransactWriteItemsErrorTransactionInProgressException(
    value: TransactionInProgressException,
  )
  TransactWriteItemsErrorTransport(reason: String)
  TransactWriteItemsErrorUnknown(error_type: String, status: Int, body: String)
}

fn transact_write_items_error_decoders() {
  [
    #("IdempotentParameterMismatchException", fn(body) {
      case
        json.parse(
          body,
          decode_idempotent_parameter_mismatch_exception_struct(),
        )
      {
        Ok(v) ->
          Ok(TransactWriteItemsErrorIdempotentParameterMismatchException(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(TransactWriteItemsErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) -> Ok(TransactWriteItemsErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ProvisionedThroughputExceededException", fn(body) {
      case
        json.parse(
          body,
          decode_provisioned_throughput_exceeded_exception_struct(),
        )
      {
        Ok(v) ->
          Ok(TransactWriteItemsErrorProvisionedThroughputExceededException(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
    #("RequestLimitExceeded", fn(body) {
      case json.parse(body, decode_request_limit_exceeded_struct()) {
        Ok(v) -> Ok(TransactWriteItemsErrorRequestLimitExceeded(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceNotFoundException", fn(body) {
      case json.parse(body, decode_resource_not_found_exception_struct()) {
        Ok(v) -> Ok(TransactWriteItemsErrorResourceNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ThrottlingException", fn(body) {
      case json.parse(body, decode_throttling_exception_struct()) {
        Ok(v) -> Ok(TransactWriteItemsErrorThrottlingException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TransactionCanceledException", fn(body) {
      case json.parse(body, decode_transaction_canceled_exception_struct()) {
        Ok(v) ->
          Ok(TransactWriteItemsErrorTransactionCanceledException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TransactionInProgressException", fn(body) {
      case json.parse(body, decode_transaction_in_progress_exception_struct()) {
        Ok(v) ->
          Ok(TransactWriteItemsErrorTransactionInProgressException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_transact_write_items_error(
  err: runtime.ClientError,
) -> TransactWriteItemsError {
  runtime.translate_service_error(
    err,
    transact_write_items_error_decoders(),
    fn(reason) { TransactWriteItemsErrorTransport(reason: reason) },
    fn(et, s, body) {
      TransactWriteItemsErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type UntagResourceOutput {
  UntagResourceOutput
}

pub fn untag_resource_output_default() -> UntagResourceOutput {
  UntagResourceOutput
}

pub fn decode_untag_resource_output_struct() -> decode.Decoder(
  UntagResourceOutput,
) {
  decode.success(UntagResourceOutput)
}

pub fn encode_untag_resource_input(input: UntagResourceInput) -> String {
  json.to_string(encode_untag_resource_input_struct_top(input))
}

pub fn decode_untag_resource_output(
  body: String,
) -> Result(UntagResourceOutput, String) {
  case json.parse(body, decode_untag_resource_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_untag_resource_request(
  input: UntagResourceInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_untag_resource_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.UntagResource"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_untag_resource_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(UntagResourceOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_untag_resource_output("{}")
        _ -> decode_untag_resource_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type UntagResourceError {
  UntagResourceErrorInternalServerError(value: InternalServerError)
  UntagResourceErrorInvalidEndpointException(value: InvalidEndpointException)
  UntagResourceErrorLimitExceededException(value: LimitExceededException)
  UntagResourceErrorResourceInUseException(value: ResourceInUseException)
  UntagResourceErrorResourceNotFoundException(value: ResourceNotFoundException)
  UntagResourceErrorTransport(reason: String)
  UntagResourceErrorUnknown(error_type: String, status: Int, body: String)
}

fn untag_resource_error_decoders() {
  [
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(UntagResourceErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) -> Ok(UntagResourceErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(UntagResourceErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceInUseException", fn(body) {
      case json.parse(body, decode_resource_in_use_exception_struct()) {
        Ok(v) -> Ok(UntagResourceErrorResourceInUseException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceNotFoundException", fn(body) {
      case json.parse(body, decode_resource_not_found_exception_struct()) {
        Ok(v) -> Ok(UntagResourceErrorResourceNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_untag_resource_error(
  err: runtime.ClientError,
) -> UntagResourceError {
  runtime.translate_service_error(
    err,
    untag_resource_error_decoders(),
    fn(reason) { UntagResourceErrorTransport(reason: reason) },
    fn(et, s, body) {
      UntagResourceErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_update_continuous_backups_input(
  input: UpdateContinuousBackupsInput,
) -> String {
  json.to_string(encode_update_continuous_backups_input_struct_top(input))
}

pub fn decode_update_continuous_backups_output(
  body: String,
) -> Result(UpdateContinuousBackupsOutput, String) {
  case json.parse(body, decode_update_continuous_backups_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_update_continuous_backups_request(
  input: UpdateContinuousBackupsInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_update_continuous_backups_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.UpdateContinuousBackups"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_update_continuous_backups_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(UpdateContinuousBackupsOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_update_continuous_backups_output("{}")
        _ -> decode_update_continuous_backups_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type UpdateContinuousBackupsError {
  UpdateContinuousBackupsErrorContinuousBackupsUnavailableException(
    value: ContinuousBackupsUnavailableException,
  )
  UpdateContinuousBackupsErrorInternalServerError(value: InternalServerError)
  UpdateContinuousBackupsErrorInvalidEndpointException(
    value: InvalidEndpointException,
  )
  UpdateContinuousBackupsErrorTableNotFoundException(
    value: TableNotFoundException,
  )
  UpdateContinuousBackupsErrorTransport(reason: String)
  UpdateContinuousBackupsErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn update_continuous_backups_error_decoders() {
  [
    #("ContinuousBackupsUnavailableException", fn(body) {
      case
        json.parse(
          body,
          decode_continuous_backups_unavailable_exception_struct(),
        )
      {
        Ok(v) ->
          Ok(UpdateContinuousBackupsErrorContinuousBackupsUnavailableException(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(UpdateContinuousBackupsErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) ->
          Ok(UpdateContinuousBackupsErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TableNotFoundException", fn(body) {
      case json.parse(body, decode_table_not_found_exception_struct()) {
        Ok(v) ->
          Ok(UpdateContinuousBackupsErrorTableNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_update_continuous_backups_error(
  err: runtime.ClientError,
) -> UpdateContinuousBackupsError {
  runtime.translate_service_error(
    err,
    update_continuous_backups_error_decoders(),
    fn(reason) { UpdateContinuousBackupsErrorTransport(reason: reason) },
    fn(et, s, body) {
      UpdateContinuousBackupsErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_update_contributor_insights_input(
  input: UpdateContributorInsightsInput,
) -> String {
  json.to_string(encode_update_contributor_insights_input_struct_top(input))
}

pub fn decode_update_contributor_insights_output(
  body: String,
) -> Result(UpdateContributorInsightsOutput, String) {
  case json.parse(body, decode_update_contributor_insights_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_update_contributor_insights_request(
  input: UpdateContributorInsightsInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_update_contributor_insights_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.UpdateContributorInsights"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_update_contributor_insights_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(UpdateContributorInsightsOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_update_contributor_insights_output("{}")
        _ -> decode_update_contributor_insights_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type UpdateContributorInsightsError {
  UpdateContributorInsightsErrorInternalServerError(value: InternalServerError)
  UpdateContributorInsightsErrorResourceNotFoundException(
    value: ResourceNotFoundException,
  )
  UpdateContributorInsightsErrorTransport(reason: String)
  UpdateContributorInsightsErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn update_contributor_insights_error_decoders() {
  [
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(UpdateContributorInsightsErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceNotFoundException", fn(body) {
      case json.parse(body, decode_resource_not_found_exception_struct()) {
        Ok(v) ->
          Ok(UpdateContributorInsightsErrorResourceNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_update_contributor_insights_error(
  err: runtime.ClientError,
) -> UpdateContributorInsightsError {
  runtime.translate_service_error(
    err,
    update_contributor_insights_error_decoders(),
    fn(reason) { UpdateContributorInsightsErrorTransport(reason: reason) },
    fn(et, s, body) {
      UpdateContributorInsightsErrorUnknown(
        error_type: et,
        status: s,
        body: body,
      )
    },
  )
}

pub fn encode_update_global_table_input(
  input: UpdateGlobalTableInput,
) -> String {
  json.to_string(encode_update_global_table_input_struct_top(input))
}

pub fn decode_update_global_table_output(
  body: String,
) -> Result(UpdateGlobalTableOutput, String) {
  case json.parse(body, decode_update_global_table_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_update_global_table_request(
  input: UpdateGlobalTableInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_update_global_table_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.UpdateGlobalTable"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_update_global_table_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(UpdateGlobalTableOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_update_global_table_output("{}")
        _ -> decode_update_global_table_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type UpdateGlobalTableError {
  UpdateGlobalTableErrorGlobalTableNotFoundException(
    value: GlobalTableNotFoundException,
  )
  UpdateGlobalTableErrorInternalServerError(value: InternalServerError)
  UpdateGlobalTableErrorInvalidEndpointException(
    value: InvalidEndpointException,
  )
  UpdateGlobalTableErrorReplicaAlreadyExistsException(
    value: ReplicaAlreadyExistsException,
  )
  UpdateGlobalTableErrorReplicaNotFoundException(
    value: ReplicaNotFoundException,
  )
  UpdateGlobalTableErrorTableNotFoundException(value: TableNotFoundException)
  UpdateGlobalTableErrorTransport(reason: String)
  UpdateGlobalTableErrorUnknown(error_type: String, status: Int, body: String)
}

fn update_global_table_error_decoders() {
  [
    #("GlobalTableNotFoundException", fn(body) {
      case json.parse(body, decode_global_table_not_found_exception_struct()) {
        Ok(v) ->
          Ok(UpdateGlobalTableErrorGlobalTableNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(UpdateGlobalTableErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) -> Ok(UpdateGlobalTableErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ReplicaAlreadyExistsException", fn(body) {
      case json.parse(body, decode_replica_already_exists_exception_struct()) {
        Ok(v) ->
          Ok(UpdateGlobalTableErrorReplicaAlreadyExistsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ReplicaNotFoundException", fn(body) {
      case json.parse(body, decode_replica_not_found_exception_struct()) {
        Ok(v) -> Ok(UpdateGlobalTableErrorReplicaNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TableNotFoundException", fn(body) {
      case json.parse(body, decode_table_not_found_exception_struct()) {
        Ok(v) -> Ok(UpdateGlobalTableErrorTableNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_update_global_table_error(
  err: runtime.ClientError,
) -> UpdateGlobalTableError {
  runtime.translate_service_error(
    err,
    update_global_table_error_decoders(),
    fn(reason) { UpdateGlobalTableErrorTransport(reason: reason) },
    fn(et, s, body) {
      UpdateGlobalTableErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_update_global_table_settings_input(
  input: UpdateGlobalTableSettingsInput,
) -> String {
  json.to_string(encode_update_global_table_settings_input_struct_top(input))
}

pub fn decode_update_global_table_settings_output(
  body: String,
) -> Result(UpdateGlobalTableSettingsOutput, String) {
  case json.parse(body, decode_update_global_table_settings_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_update_global_table_settings_request(
  input: UpdateGlobalTableSettingsInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_update_global_table_settings_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.UpdateGlobalTableSettings"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_update_global_table_settings_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(UpdateGlobalTableSettingsOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_update_global_table_settings_output("{}")
        _ -> decode_update_global_table_settings_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type UpdateGlobalTableSettingsError {
  UpdateGlobalTableSettingsErrorGlobalTableNotFoundException(
    value: GlobalTableNotFoundException,
  )
  UpdateGlobalTableSettingsErrorIndexNotFoundException(
    value: IndexNotFoundException,
  )
  UpdateGlobalTableSettingsErrorInternalServerError(value: InternalServerError)
  UpdateGlobalTableSettingsErrorInvalidEndpointException(
    value: InvalidEndpointException,
  )
  UpdateGlobalTableSettingsErrorLimitExceededException(
    value: LimitExceededException,
  )
  UpdateGlobalTableSettingsErrorReplicaNotFoundException(
    value: ReplicaNotFoundException,
  )
  UpdateGlobalTableSettingsErrorResourceInUseException(
    value: ResourceInUseException,
  )
  UpdateGlobalTableSettingsErrorTransport(reason: String)
  UpdateGlobalTableSettingsErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn update_global_table_settings_error_decoders() {
  [
    #("GlobalTableNotFoundException", fn(body) {
      case json.parse(body, decode_global_table_not_found_exception_struct()) {
        Ok(v) ->
          Ok(UpdateGlobalTableSettingsErrorGlobalTableNotFoundException(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
    #("IndexNotFoundException", fn(body) {
      case json.parse(body, decode_index_not_found_exception_struct()) {
        Ok(v) ->
          Ok(UpdateGlobalTableSettingsErrorIndexNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(UpdateGlobalTableSettingsErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) ->
          Ok(UpdateGlobalTableSettingsErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) ->
          Ok(UpdateGlobalTableSettingsErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ReplicaNotFoundException", fn(body) {
      case json.parse(body, decode_replica_not_found_exception_struct()) {
        Ok(v) ->
          Ok(UpdateGlobalTableSettingsErrorReplicaNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceInUseException", fn(body) {
      case json.parse(body, decode_resource_in_use_exception_struct()) {
        Ok(v) ->
          Ok(UpdateGlobalTableSettingsErrorResourceInUseException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_update_global_table_settings_error(
  err: runtime.ClientError,
) -> UpdateGlobalTableSettingsError {
  runtime.translate_service_error(
    err,
    update_global_table_settings_error_decoders(),
    fn(reason) { UpdateGlobalTableSettingsErrorTransport(reason: reason) },
    fn(et, s, body) {
      UpdateGlobalTableSettingsErrorUnknown(
        error_type: et,
        status: s,
        body: body,
      )
    },
  )
}

pub fn encode_update_item_input(input: UpdateItemInput) -> String {
  json.to_string(encode_update_item_input_struct_top(input))
}

pub fn decode_update_item_output(
  body: String,
) -> Result(UpdateItemOutput, String) {
  case json.parse(body, decode_update_item_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_update_item_request(
  input: UpdateItemInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_update_item_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.UpdateItem"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_update_item_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(UpdateItemOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_update_item_output("{}")
        _ -> decode_update_item_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type UpdateItemError {
  UpdateItemErrorConditionalCheckFailedException(
    value: ConditionalCheckFailedException,
  )
  UpdateItemErrorInternalServerError(value: InternalServerError)
  UpdateItemErrorInvalidEndpointException(value: InvalidEndpointException)
  UpdateItemErrorItemCollectionSizeLimitExceededException(
    value: ItemCollectionSizeLimitExceededException,
  )
  UpdateItemErrorProvisionedThroughputExceededException(
    value: ProvisionedThroughputExceededException,
  )
  UpdateItemErrorReplicatedWriteConflictException(
    value: ReplicatedWriteConflictException,
  )
  UpdateItemErrorRequestLimitExceeded(value: RequestLimitExceeded)
  UpdateItemErrorResourceNotFoundException(value: ResourceNotFoundException)
  UpdateItemErrorThrottlingException(value: ThrottlingException)
  UpdateItemErrorTransactionConflictException(
    value: TransactionConflictException,
  )
  UpdateItemErrorTransport(reason: String)
  UpdateItemErrorUnknown(error_type: String, status: Int, body: String)
}

fn update_item_error_decoders() {
  [
    #("ConditionalCheckFailedException", fn(body) {
      case
        json.parse(body, decode_conditional_check_failed_exception_struct())
      {
        Ok(v) -> Ok(UpdateItemErrorConditionalCheckFailedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(UpdateItemErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) -> Ok(UpdateItemErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ItemCollectionSizeLimitExceededException", fn(body) {
      case
        json.parse(
          body,
          decode_item_collection_size_limit_exceeded_exception_struct(),
        )
      {
        Ok(v) ->
          Ok(UpdateItemErrorItemCollectionSizeLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ProvisionedThroughputExceededException", fn(body) {
      case
        json.parse(
          body,
          decode_provisioned_throughput_exceeded_exception_struct(),
        )
      {
        Ok(v) ->
          Ok(UpdateItemErrorProvisionedThroughputExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ReplicatedWriteConflictException", fn(body) {
      case
        json.parse(body, decode_replicated_write_conflict_exception_struct())
      {
        Ok(v) -> Ok(UpdateItemErrorReplicatedWriteConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("RequestLimitExceeded", fn(body) {
      case json.parse(body, decode_request_limit_exceeded_struct()) {
        Ok(v) -> Ok(UpdateItemErrorRequestLimitExceeded(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceNotFoundException", fn(body) {
      case json.parse(body, decode_resource_not_found_exception_struct()) {
        Ok(v) -> Ok(UpdateItemErrorResourceNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ThrottlingException", fn(body) {
      case json.parse(body, decode_throttling_exception_struct()) {
        Ok(v) -> Ok(UpdateItemErrorThrottlingException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TransactionConflictException", fn(body) {
      case json.parse(body, decode_transaction_conflict_exception_struct()) {
        Ok(v) -> Ok(UpdateItemErrorTransactionConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_update_item_error(err: runtime.ClientError) -> UpdateItemError {
  runtime.translate_service_error(
    err,
    update_item_error_decoders(),
    fn(reason) { UpdateItemErrorTransport(reason: reason) },
    fn(et, s, body) {
      UpdateItemErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_update_kinesis_streaming_destination_input(
  input: UpdateKinesisStreamingDestinationInput,
) -> String {
  json.to_string(encode_update_kinesis_streaming_destination_input_struct_top(
    input,
  ))
}

pub fn decode_update_kinesis_streaming_destination_output(
  body: String,
) -> Result(UpdateKinesisStreamingDestinationOutput, String) {
  case
    json.parse(
      body,
      decode_update_kinesis_streaming_destination_output_struct(),
    )
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_update_kinesis_streaming_destination_request(
  input: UpdateKinesisStreamingDestinationInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_update_kinesis_streaming_destination_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.UpdateKinesisStreamingDestination"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_update_kinesis_streaming_destination_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(UpdateKinesisStreamingDestinationOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_update_kinesis_streaming_destination_output("{}")
        _ -> decode_update_kinesis_streaming_destination_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type UpdateKinesisStreamingDestinationError {
  UpdateKinesisStreamingDestinationErrorInternalServerError(
    value: InternalServerError,
  )
  UpdateKinesisStreamingDestinationErrorInvalidEndpointException(
    value: InvalidEndpointException,
  )
  UpdateKinesisStreamingDestinationErrorLimitExceededException(
    value: LimitExceededException,
  )
  UpdateKinesisStreamingDestinationErrorResourceInUseException(
    value: ResourceInUseException,
  )
  UpdateKinesisStreamingDestinationErrorResourceNotFoundException(
    value: ResourceNotFoundException,
  )
  UpdateKinesisStreamingDestinationErrorTransport(reason: String)
  UpdateKinesisStreamingDestinationErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn update_kinesis_streaming_destination_error_decoders() {
  [
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) ->
          Ok(UpdateKinesisStreamingDestinationErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) ->
          Ok(UpdateKinesisStreamingDestinationErrorInvalidEndpointException(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) ->
          Ok(UpdateKinesisStreamingDestinationErrorLimitExceededException(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceInUseException", fn(body) {
      case json.parse(body, decode_resource_in_use_exception_struct()) {
        Ok(v) ->
          Ok(UpdateKinesisStreamingDestinationErrorResourceInUseException(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceNotFoundException", fn(body) {
      case json.parse(body, decode_resource_not_found_exception_struct()) {
        Ok(v) ->
          Ok(UpdateKinesisStreamingDestinationErrorResourceNotFoundException(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_update_kinesis_streaming_destination_error(
  err: runtime.ClientError,
) -> UpdateKinesisStreamingDestinationError {
  runtime.translate_service_error(
    err,
    update_kinesis_streaming_destination_error_decoders(),
    fn(reason) {
      UpdateKinesisStreamingDestinationErrorTransport(reason: reason)
    },
    fn(et, s, body) {
      UpdateKinesisStreamingDestinationErrorUnknown(
        error_type: et,
        status: s,
        body: body,
      )
    },
  )
}

pub fn encode_update_table_input(input: UpdateTableInput) -> String {
  json.to_string(encode_update_table_input_struct_top(input))
}

pub fn decode_update_table_output(
  body: String,
) -> Result(UpdateTableOutput, String) {
  case json.parse(body, decode_update_table_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_update_table_request(
  input: UpdateTableInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_update_table_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.UpdateTable"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_update_table_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(UpdateTableOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_update_table_output("{}")
        _ -> decode_update_table_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type UpdateTableError {
  UpdateTableErrorInternalServerError(value: InternalServerError)
  UpdateTableErrorInvalidEndpointException(value: InvalidEndpointException)
  UpdateTableErrorLimitExceededException(value: LimitExceededException)
  UpdateTableErrorResourceInUseException(value: ResourceInUseException)
  UpdateTableErrorResourceNotFoundException(value: ResourceNotFoundException)
  UpdateTableErrorTransport(reason: String)
  UpdateTableErrorUnknown(error_type: String, status: Int, body: String)
}

fn update_table_error_decoders() {
  [
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(UpdateTableErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) -> Ok(UpdateTableErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(UpdateTableErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceInUseException", fn(body) {
      case json.parse(body, decode_resource_in_use_exception_struct()) {
        Ok(v) -> Ok(UpdateTableErrorResourceInUseException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceNotFoundException", fn(body) {
      case json.parse(body, decode_resource_not_found_exception_struct()) {
        Ok(v) -> Ok(UpdateTableErrorResourceNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_update_table_error(err: runtime.ClientError) -> UpdateTableError {
  runtime.translate_service_error(
    err,
    update_table_error_decoders(),
    fn(reason) { UpdateTableErrorTransport(reason: reason) },
    fn(et, s, body) {
      UpdateTableErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn encode_update_table_replica_auto_scaling_input(
  input: UpdateTableReplicaAutoScalingInput,
) -> String {
  json.to_string(encode_update_table_replica_auto_scaling_input_struct_top(
    input,
  ))
}

pub fn decode_update_table_replica_auto_scaling_output(
  body: String,
) -> Result(UpdateTableReplicaAutoScalingOutput, String) {
  case
    json.parse(body, decode_update_table_replica_auto_scaling_output_struct())
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_update_table_replica_auto_scaling_request(
  input: UpdateTableReplicaAutoScalingInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_update_table_replica_auto_scaling_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.UpdateTableReplicaAutoScaling"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_update_table_replica_auto_scaling_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(UpdateTableReplicaAutoScalingOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_update_table_replica_auto_scaling_output("{}")
        _ -> decode_update_table_replica_auto_scaling_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type UpdateTableReplicaAutoScalingError {
  UpdateTableReplicaAutoScalingErrorInternalServerError(
    value: InternalServerError,
  )
  UpdateTableReplicaAutoScalingErrorLimitExceededException(
    value: LimitExceededException,
  )
  UpdateTableReplicaAutoScalingErrorResourceInUseException(
    value: ResourceInUseException,
  )
  UpdateTableReplicaAutoScalingErrorResourceNotFoundException(
    value: ResourceNotFoundException,
  )
  UpdateTableReplicaAutoScalingErrorTransport(reason: String)
  UpdateTableReplicaAutoScalingErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn update_table_replica_auto_scaling_error_decoders() {
  [
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) ->
          Ok(UpdateTableReplicaAutoScalingErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) ->
          Ok(UpdateTableReplicaAutoScalingErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceInUseException", fn(body) {
      case json.parse(body, decode_resource_in_use_exception_struct()) {
        Ok(v) ->
          Ok(UpdateTableReplicaAutoScalingErrorResourceInUseException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceNotFoundException", fn(body) {
      case json.parse(body, decode_resource_not_found_exception_struct()) {
        Ok(v) ->
          Ok(UpdateTableReplicaAutoScalingErrorResourceNotFoundException(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_update_table_replica_auto_scaling_error(
  err: runtime.ClientError,
) -> UpdateTableReplicaAutoScalingError {
  runtime.translate_service_error(
    err,
    update_table_replica_auto_scaling_error_decoders(),
    fn(reason) { UpdateTableReplicaAutoScalingErrorTransport(reason: reason) },
    fn(et, s, body) {
      UpdateTableReplicaAutoScalingErrorUnknown(
        error_type: et,
        status: s,
        body: body,
      )
    },
  )
}

pub fn encode_update_time_to_live_input(
  input: UpdateTimeToLiveInput,
) -> String {
  json.to_string(encode_update_time_to_live_input_struct_top(input))
}

pub fn decode_update_time_to_live_output(
  body: String,
) -> Result(UpdateTimeToLiveOutput, String) {
  case json.parse(body, decode_update_time_to_live_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn build_update_time_to_live_request(
  input: UpdateTimeToLiveInput,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let body_str = encode_update_time_to_live_input(input)
  let body = bit_array.from_string(body_str)
  let headers =
    dict.from_list([
      #("Content-Type", "application/x-amz-json-1.0"),
      #("Content-Length", int.to_string(bit_array.byte_size(body))),
      #("X-Amz-Target", "DynamoDB_20120810.UpdateTimeToLive"),
    ])
  #("POST", "/", headers, body)
}

pub fn parse_update_time_to_live_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(UpdateTimeToLiveOutput, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_update_time_to_live_output("{}")
        _ -> decode_update_time_to_live_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type UpdateTimeToLiveError {
  UpdateTimeToLiveErrorInternalServerError(value: InternalServerError)
  UpdateTimeToLiveErrorInvalidEndpointException(value: InvalidEndpointException)
  UpdateTimeToLiveErrorLimitExceededException(value: LimitExceededException)
  UpdateTimeToLiveErrorResourceInUseException(value: ResourceInUseException)
  UpdateTimeToLiveErrorResourceNotFoundException(
    value: ResourceNotFoundException,
  )
  UpdateTimeToLiveErrorTransport(reason: String)
  UpdateTimeToLiveErrorUnknown(error_type: String, status: Int, body: String)
}

fn update_time_to_live_error_decoders() {
  [
    #("InternalServerError", fn(body) {
      case json.parse(body, decode_internal_server_error_struct()) {
        Ok(v) -> Ok(UpdateTimeToLiveErrorInternalServerError(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("InvalidEndpointException", fn(body) {
      case json.parse(body, decode_invalid_endpoint_exception_struct()) {
        Ok(v) -> Ok(UpdateTimeToLiveErrorInvalidEndpointException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(UpdateTimeToLiveErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceInUseException", fn(body) {
      case json.parse(body, decode_resource_in_use_exception_struct()) {
        Ok(v) -> Ok(UpdateTimeToLiveErrorResourceInUseException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ResourceNotFoundException", fn(body) {
      case json.parse(body, decode_resource_not_found_exception_struct()) {
        Ok(v) -> Ok(UpdateTimeToLiveErrorResourceNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_update_time_to_live_error(
  err: runtime.ClientError,
) -> UpdateTimeToLiveError {
  runtime.translate_service_error(
    err,
    update_time_to_live_error_decoders(),
    fn(reason) { UpdateTimeToLiveErrorTransport(reason: reason) },
    fn(et, s, body) {
      UpdateTimeToLiveErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

/// Invoke BatchExecuteStatement. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `BatchExecuteStatementError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `BatchExecuteStatementErrorTransport` variant.
pub fn batch_execute_statement(
  client: Client,
  input: BatchExecuteStatementInput,
) -> Result(BatchExecuteStatementOutput, BatchExecuteStatementError) {
  case
    runtime.invoke(
      client.config,
      build_batch_execute_statement_request(input),
      parse_batch_execute_statement_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_batch_execute_statement_error(err))
  }
}

/// Invoke BatchGetItem. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `BatchGetItemError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `BatchGetItemErrorTransport` variant.
pub fn batch_get_item(
  client: Client,
  input: BatchGetItemInput,
) -> Result(BatchGetItemOutput, BatchGetItemError) {
  case
    runtime.invoke(
      client.config,
      build_batch_get_item_request(input),
      parse_batch_get_item_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_batch_get_item_error(err))
  }
}

/// Invoke BatchWriteItem. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `BatchWriteItemError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `BatchWriteItemErrorTransport` variant.
pub fn batch_write_item(
  client: Client,
  input: BatchWriteItemInput,
) -> Result(BatchWriteItemOutput, BatchWriteItemError) {
  case
    runtime.invoke(
      client.config,
      build_batch_write_item_request(input),
      parse_batch_write_item_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_batch_write_item_error(err))
  }
}

/// Invoke CreateBackup. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `CreateBackupError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `CreateBackupErrorTransport` variant.
pub fn create_backup(
  client: Client,
  input: CreateBackupInput,
) -> Result(CreateBackupOutput, CreateBackupError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_create_backup_endpoint_params(input),
      build_create_backup_request(input),
      parse_create_backup_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_create_backup_error(err))
  }
}

fn build_create_backup_endpoint_params(
  input: CreateBackupInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.table_name {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke CreateGlobalTable. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `CreateGlobalTableError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `CreateGlobalTableErrorTransport` variant.
pub fn create_global_table(
  client: Client,
  input: CreateGlobalTableInput,
) -> Result(CreateGlobalTableOutput, CreateGlobalTableError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_create_global_table_endpoint_params(input),
      build_create_global_table_request(input),
      parse_create_global_table_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_create_global_table_error(err))
  }
}

fn build_create_global_table_endpoint_params(
  input: CreateGlobalTableInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.global_table_name {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke CreateTable. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `CreateTableError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `CreateTableErrorTransport` variant.
pub fn create_table(
  client: Client,
  input: CreateTableInput,
) -> Result(CreateTableOutput, CreateTableError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_create_table_endpoint_params(input),
      build_create_table_request(input),
      parse_create_table_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_create_table_error(err))
  }
}

fn build_create_table_endpoint_params(
  input: CreateTableInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.table_name {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke DeleteBackup. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `DeleteBackupError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `DeleteBackupErrorTransport` variant.
pub fn delete_backup(
  client: Client,
  input: DeleteBackupInput,
) -> Result(DeleteBackupOutput, DeleteBackupError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_delete_backup_endpoint_params(input),
      build_delete_backup_request(input),
      parse_delete_backup_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_delete_backup_error(err))
  }
}

fn build_delete_backup_endpoint_params(
  input: DeleteBackupInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.backup_arn {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke DeleteItem. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `DeleteItemError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `DeleteItemErrorTransport` variant.
pub fn delete_item(
  client: Client,
  input: DeleteItemInput,
) -> Result(DeleteItemOutput, DeleteItemError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_delete_item_endpoint_params(input),
      build_delete_item_request(input),
      parse_delete_item_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_delete_item_error(err))
  }
}

fn build_delete_item_endpoint_params(
  input: DeleteItemInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.table_name {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke DeleteResourcePolicy. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `DeleteResourcePolicyError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `DeleteResourcePolicyErrorTransport` variant.
pub fn delete_resource_policy(
  client: Client,
  input: DeleteResourcePolicyInput,
) -> Result(DeleteResourcePolicyOutput, DeleteResourcePolicyError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_delete_resource_policy_endpoint_params(input),
      build_delete_resource_policy_request(input),
      parse_delete_resource_policy_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_delete_resource_policy_error(err))
  }
}

fn build_delete_resource_policy_endpoint_params(
  input: DeleteResourcePolicyInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.resource_arn {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke DeleteTable. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `DeleteTableError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `DeleteTableErrorTransport` variant.
pub fn delete_table(
  client: Client,
  input: DeleteTableInput,
) -> Result(DeleteTableOutput, DeleteTableError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_delete_table_endpoint_params(input),
      build_delete_table_request(input),
      parse_delete_table_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_delete_table_error(err))
  }
}

fn build_delete_table_endpoint_params(
  input: DeleteTableInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.table_name {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke DescribeBackup. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `DescribeBackupError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `DescribeBackupErrorTransport` variant.
pub fn describe_backup(
  client: Client,
  input: DescribeBackupInput,
) -> Result(DescribeBackupOutput, DescribeBackupError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_describe_backup_endpoint_params(input),
      build_describe_backup_request(input),
      parse_describe_backup_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_describe_backup_error(err))
  }
}

fn build_describe_backup_endpoint_params(
  input: DescribeBackupInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.backup_arn {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke DescribeContinuousBackups. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `DescribeContinuousBackupsError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `DescribeContinuousBackupsErrorTransport` variant.
pub fn describe_continuous_backups(
  client: Client,
  input: DescribeContinuousBackupsInput,
) -> Result(DescribeContinuousBackupsOutput, DescribeContinuousBackupsError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_describe_continuous_backups_endpoint_params(input),
      build_describe_continuous_backups_request(input),
      parse_describe_continuous_backups_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_describe_continuous_backups_error(err))
  }
}

fn build_describe_continuous_backups_endpoint_params(
  input: DescribeContinuousBackupsInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.table_name {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke DescribeContributorInsights. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `DescribeContributorInsightsError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `DescribeContributorInsightsErrorTransport` variant.
pub fn describe_contributor_insights(
  client: Client,
  input: DescribeContributorInsightsInput,
) -> Result(DescribeContributorInsightsOutput, DescribeContributorInsightsError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_describe_contributor_insights_endpoint_params(input),
      build_describe_contributor_insights_request(input),
      parse_describe_contributor_insights_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_describe_contributor_insights_error(err))
  }
}

fn build_describe_contributor_insights_endpoint_params(
  input: DescribeContributorInsightsInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.table_name {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke DescribeEndpoints. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `DescribeEndpointsError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `DescribeEndpointsErrorTransport` variant.
pub fn describe_endpoints(
  client: Client,
  input: DescribeEndpointsRequest,
) -> Result(DescribeEndpointsResponse, DescribeEndpointsError) {
  case
    runtime.invoke(
      client.config,
      build_describe_endpoints_request(input),
      parse_describe_endpoints_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_describe_endpoints_error(err))
  }
}

/// Invoke DescribeExport. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `DescribeExportError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `DescribeExportErrorTransport` variant.
pub fn describe_export(
  client: Client,
  input: DescribeExportInput,
) -> Result(DescribeExportOutput, DescribeExportError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_describe_export_endpoint_params(input),
      build_describe_export_request(input),
      parse_describe_export_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_describe_export_error(err))
  }
}

fn build_describe_export_endpoint_params(
  input: DescribeExportInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.export_arn {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke DescribeGlobalTable. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `DescribeGlobalTableError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `DescribeGlobalTableErrorTransport` variant.
pub fn describe_global_table(
  client: Client,
  input: DescribeGlobalTableInput,
) -> Result(DescribeGlobalTableOutput, DescribeGlobalTableError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_describe_global_table_endpoint_params(input),
      build_describe_global_table_request(input),
      parse_describe_global_table_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_describe_global_table_error(err))
  }
}

fn build_describe_global_table_endpoint_params(
  input: DescribeGlobalTableInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.global_table_name {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke DescribeGlobalTableSettings. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `DescribeGlobalTableSettingsError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `DescribeGlobalTableSettingsErrorTransport` variant.
pub fn describe_global_table_settings(
  client: Client,
  input: DescribeGlobalTableSettingsInput,
) -> Result(DescribeGlobalTableSettingsOutput, DescribeGlobalTableSettingsError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_describe_global_table_settings_endpoint_params(input),
      build_describe_global_table_settings_request(input),
      parse_describe_global_table_settings_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_describe_global_table_settings_error(err))
  }
}

fn build_describe_global_table_settings_endpoint_params(
  input: DescribeGlobalTableSettingsInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.global_table_name {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke DescribeImport. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `DescribeImportError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `DescribeImportErrorTransport` variant.
pub fn describe_import(
  client: Client,
  input: DescribeImportInput,
) -> Result(DescribeImportOutput, DescribeImportError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_describe_import_endpoint_params(input),
      build_describe_import_request(input),
      parse_describe_import_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_describe_import_error(err))
  }
}

fn build_describe_import_endpoint_params(
  input: DescribeImportInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.import_arn {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke DescribeKinesisStreamingDestination. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `DescribeKinesisStreamingDestinationError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `DescribeKinesisStreamingDestinationErrorTransport` variant.
pub fn describe_kinesis_streaming_destination(
  client: Client,
  input: DescribeKinesisStreamingDestinationInput,
) -> Result(
  DescribeKinesisStreamingDestinationOutput,
  DescribeKinesisStreamingDestinationError,
) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_describe_kinesis_streaming_destination_endpoint_params(input),
      build_describe_kinesis_streaming_destination_request(input),
      parse_describe_kinesis_streaming_destination_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) ->
      Error(translate_describe_kinesis_streaming_destination_error(err))
  }
}

fn build_describe_kinesis_streaming_destination_endpoint_params(
  input: DescribeKinesisStreamingDestinationInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.table_name {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke DescribeLimits. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `DescribeLimitsError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `DescribeLimitsErrorTransport` variant.
pub fn describe_limits(
  client: Client,
  input: DescribeLimitsInput,
) -> Result(DescribeLimitsOutput, DescribeLimitsError) {
  case
    runtime.invoke(
      client.config,
      build_describe_limits_request(input),
      parse_describe_limits_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_describe_limits_error(err))
  }
}

/// Invoke DescribeTable. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `DescribeTableError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `DescribeTableErrorTransport` variant.
pub fn describe_table(
  client: Client,
  input: DescribeTableInput,
) -> Result(DescribeTableOutput, DescribeTableError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_describe_table_endpoint_params(input),
      build_describe_table_request(input),
      parse_describe_table_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_describe_table_error(err))
  }
}

fn build_describe_table_endpoint_params(
  input: DescribeTableInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.table_name {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke DescribeTableReplicaAutoScaling. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `DescribeTableReplicaAutoScalingError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `DescribeTableReplicaAutoScalingErrorTransport` variant.
pub fn describe_table_replica_auto_scaling(
  client: Client,
  input: DescribeTableReplicaAutoScalingInput,
) -> Result(
  DescribeTableReplicaAutoScalingOutput,
  DescribeTableReplicaAutoScalingError,
) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_describe_table_replica_auto_scaling_endpoint_params(input),
      build_describe_table_replica_auto_scaling_request(input),
      parse_describe_table_replica_auto_scaling_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) ->
      Error(translate_describe_table_replica_auto_scaling_error(err))
  }
}

fn build_describe_table_replica_auto_scaling_endpoint_params(
  input: DescribeTableReplicaAutoScalingInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.table_name {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke DescribeTimeToLive. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `DescribeTimeToLiveError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `DescribeTimeToLiveErrorTransport` variant.
pub fn describe_time_to_live(
  client: Client,
  input: DescribeTimeToLiveInput,
) -> Result(DescribeTimeToLiveOutput, DescribeTimeToLiveError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_describe_time_to_live_endpoint_params(input),
      build_describe_time_to_live_request(input),
      parse_describe_time_to_live_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_describe_time_to_live_error(err))
  }
}

fn build_describe_time_to_live_endpoint_params(
  input: DescribeTimeToLiveInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.table_name {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke DisableKinesisStreamingDestination. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `DisableKinesisStreamingDestinationError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `DisableKinesisStreamingDestinationErrorTransport` variant.
pub fn disable_kinesis_streaming_destination(
  client: Client,
  input: KinesisStreamingDestinationInput,
) -> Result(
  KinesisStreamingDestinationOutput,
  DisableKinesisStreamingDestinationError,
) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_disable_kinesis_streaming_destination_endpoint_params(input),
      build_disable_kinesis_streaming_destination_request(input),
      parse_disable_kinesis_streaming_destination_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) ->
      Error(translate_disable_kinesis_streaming_destination_error(err))
  }
}

fn build_disable_kinesis_streaming_destination_endpoint_params(
  input: KinesisStreamingDestinationInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.table_name {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke EnableKinesisStreamingDestination. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `EnableKinesisStreamingDestinationError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `EnableKinesisStreamingDestinationErrorTransport` variant.
pub fn enable_kinesis_streaming_destination(
  client: Client,
  input: KinesisStreamingDestinationInput,
) -> Result(
  KinesisStreamingDestinationOutput,
  EnableKinesisStreamingDestinationError,
) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_enable_kinesis_streaming_destination_endpoint_params(input),
      build_enable_kinesis_streaming_destination_request(input),
      parse_enable_kinesis_streaming_destination_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) ->
      Error(translate_enable_kinesis_streaming_destination_error(err))
  }
}

fn build_enable_kinesis_streaming_destination_endpoint_params(
  input: KinesisStreamingDestinationInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.table_name {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke ExecuteStatement. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `ExecuteStatementError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `ExecuteStatementErrorTransport` variant.
pub fn execute_statement(
  client: Client,
  input: ExecuteStatementInput,
) -> Result(ExecuteStatementOutput, ExecuteStatementError) {
  case
    runtime.invoke(
      client.config,
      build_execute_statement_request(input),
      parse_execute_statement_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_execute_statement_error(err))
  }
}

/// Invoke ExecuteTransaction. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `ExecuteTransactionError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `ExecuteTransactionErrorTransport` variant.
pub fn execute_transaction(
  client: Client,
  input: ExecuteTransactionInput,
) -> Result(ExecuteTransactionOutput, ExecuteTransactionError) {
  case
    runtime.invoke(
      client.config,
      build_execute_transaction_request(input),
      parse_execute_transaction_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_execute_transaction_error(err))
  }
}

/// Invoke ExportTableToPointInTime. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `ExportTableToPointInTimeError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `ExportTableToPointInTimeErrorTransport` variant.
pub fn export_table_to_point_in_time(
  client: Client,
  input: ExportTableToPointInTimeInput,
) -> Result(ExportTableToPointInTimeOutput, ExportTableToPointInTimeError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_export_table_to_point_in_time_endpoint_params(input),
      build_export_table_to_point_in_time_request(input),
      parse_export_table_to_point_in_time_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_export_table_to_point_in_time_error(err))
  }
}

fn build_export_table_to_point_in_time_endpoint_params(
  input: ExportTableToPointInTimeInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.table_arn {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke GetItem. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `GetItemError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `GetItemErrorTransport` variant.
pub fn get_item(
  client: Client,
  input: GetItemInput,
) -> Result(GetItemOutput, GetItemError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_get_item_endpoint_params(input),
      build_get_item_request(input),
      parse_get_item_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_item_error(err))
  }
}

fn build_get_item_endpoint_params(
  input: GetItemInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.table_name {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke GetResourcePolicy. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `GetResourcePolicyError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `GetResourcePolicyErrorTransport` variant.
pub fn get_resource_policy(
  client: Client,
  input: GetResourcePolicyInput,
) -> Result(GetResourcePolicyOutput, GetResourcePolicyError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_get_resource_policy_endpoint_params(input),
      build_get_resource_policy_request(input),
      parse_get_resource_policy_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_resource_policy_error(err))
  }
}

fn build_get_resource_policy_endpoint_params(
  input: GetResourcePolicyInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.resource_arn {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke ImportTable. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `ImportTableError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `ImportTableErrorTransport` variant.
pub fn import_table(
  client: Client,
  input: ImportTableInput,
) -> Result(ImportTableOutput, ImportTableError) {
  case
    runtime.invoke(
      client.config,
      build_import_table_request(input),
      parse_import_table_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_import_table_error(err))
  }
}

/// Invoke ListBackups. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `ListBackupsError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `ListBackupsErrorTransport` variant.
pub fn list_backups(
  client: Client,
  input: ListBackupsInput,
) -> Result(ListBackupsOutput, ListBackupsError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_list_backups_endpoint_params(input),
      build_list_backups_request(input),
      parse_list_backups_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_list_backups_error(err))
  }
}

fn build_list_backups_endpoint_params(
  input: ListBackupsInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.table_name {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke ListContributorInsights. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `ListContributorInsightsError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `ListContributorInsightsErrorTransport` variant.
pub fn list_contributor_insights(
  client: Client,
  input: ListContributorInsightsInput,
) -> Result(ListContributorInsightsOutput, ListContributorInsightsError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_list_contributor_insights_endpoint_params(input),
      build_list_contributor_insights_request(input),
      parse_list_contributor_insights_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_list_contributor_insights_error(err))
  }
}

fn build_list_contributor_insights_endpoint_params(
  input: ListContributorInsightsInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.table_name {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke ListExports. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `ListExportsError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `ListExportsErrorTransport` variant.
pub fn list_exports(
  client: Client,
  input: ListExportsInput,
) -> Result(ListExportsOutput, ListExportsError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_list_exports_endpoint_params(input),
      build_list_exports_request(input),
      parse_list_exports_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_list_exports_error(err))
  }
}

fn build_list_exports_endpoint_params(
  input: ListExportsInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.table_arn {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke ListGlobalTables. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `ListGlobalTablesError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `ListGlobalTablesErrorTransport` variant.
pub fn list_global_tables(
  client: Client,
  input: ListGlobalTablesInput,
) -> Result(ListGlobalTablesOutput, ListGlobalTablesError) {
  case
    runtime.invoke(
      client.config,
      build_list_global_tables_request(input),
      parse_list_global_tables_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_list_global_tables_error(err))
  }
}

/// Invoke ListImports. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `ListImportsError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `ListImportsErrorTransport` variant.
pub fn list_imports(
  client: Client,
  input: ListImportsInput,
) -> Result(ListImportsOutput, ListImportsError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_list_imports_endpoint_params(input),
      build_list_imports_request(input),
      parse_list_imports_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_list_imports_error(err))
  }
}

fn build_list_imports_endpoint_params(
  input: ListImportsInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.table_arn {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke ListTables. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `ListTablesError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `ListTablesErrorTransport` variant.
pub fn list_tables(
  client: Client,
  input: ListTablesInput,
) -> Result(ListTablesOutput, ListTablesError) {
  case
    runtime.invoke(
      client.config,
      build_list_tables_request(input),
      parse_list_tables_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_list_tables_error(err))
  }
}

/// Invoke ListTagsOfResource. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `ListTagsOfResourceError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `ListTagsOfResourceErrorTransport` variant.
pub fn list_tags_of_resource(
  client: Client,
  input: ListTagsOfResourceInput,
) -> Result(ListTagsOfResourceOutput, ListTagsOfResourceError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_list_tags_of_resource_endpoint_params(input),
      build_list_tags_of_resource_request(input),
      parse_list_tags_of_resource_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_list_tags_of_resource_error(err))
  }
}

fn build_list_tags_of_resource_endpoint_params(
  input: ListTagsOfResourceInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.resource_arn {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke PutItem. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `PutItemError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `PutItemErrorTransport` variant.
pub fn put_item(
  client: Client,
  input: PutItemInput,
) -> Result(PutItemOutput, PutItemError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_put_item_endpoint_params(input),
      build_put_item_request(input),
      parse_put_item_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_put_item_error(err))
  }
}

fn build_put_item_endpoint_params(
  input: PutItemInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.table_name {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke PutResourcePolicy. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `PutResourcePolicyError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `PutResourcePolicyErrorTransport` variant.
pub fn put_resource_policy(
  client: Client,
  input: PutResourcePolicyInput,
) -> Result(PutResourcePolicyOutput, PutResourcePolicyError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_put_resource_policy_endpoint_params(input),
      build_put_resource_policy_request(input),
      parse_put_resource_policy_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_put_resource_policy_error(err))
  }
}

fn build_put_resource_policy_endpoint_params(
  input: PutResourcePolicyInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.resource_arn {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke Query. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `QueryError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `QueryErrorTransport` variant.
pub fn query(
  client: Client,
  input: QueryInput,
) -> Result(QueryOutput, QueryError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_query_endpoint_params(input),
      build_query_request(input),
      parse_query_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_query_error(err))
  }
}

fn build_query_endpoint_params(
  input: QueryInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.table_name {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke RestoreTableFromBackup. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `RestoreTableFromBackupError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `RestoreTableFromBackupErrorTransport` variant.
pub fn restore_table_from_backup(
  client: Client,
  input: RestoreTableFromBackupInput,
) -> Result(RestoreTableFromBackupOutput, RestoreTableFromBackupError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_restore_table_from_backup_endpoint_params(input),
      build_restore_table_from_backup_request(input),
      parse_restore_table_from_backup_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_restore_table_from_backup_error(err))
  }
}

fn build_restore_table_from_backup_endpoint_params(
  input: RestoreTableFromBackupInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.target_table_name {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke RestoreTableToPointInTime. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `RestoreTableToPointInTimeError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `RestoreTableToPointInTimeErrorTransport` variant.
pub fn restore_table_to_point_in_time(
  client: Client,
  input: RestoreTableToPointInTimeInput,
) -> Result(RestoreTableToPointInTimeOutput, RestoreTableToPointInTimeError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_restore_table_to_point_in_time_endpoint_params(input),
      build_restore_table_to_point_in_time_request(input),
      parse_restore_table_to_point_in_time_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_restore_table_to_point_in_time_error(err))
  }
}

fn build_restore_table_to_point_in_time_endpoint_params(
  input: RestoreTableToPointInTimeInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.target_table_name {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke Scan. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `ScanError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `ScanErrorTransport` variant.
pub fn scan(client: Client, input: ScanInput) -> Result(ScanOutput, ScanError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_scan_endpoint_params(input),
      build_scan_request(input),
      parse_scan_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_scan_error(err))
  }
}

fn build_scan_endpoint_params(
  input: ScanInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.table_name {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke TagResource. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `TagResourceError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `TagResourceErrorTransport` variant.
pub fn tag_resource(
  client: Client,
  input: TagResourceInput,
) -> Result(TagResourceOutput, TagResourceError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_tag_resource_endpoint_params(input),
      build_tag_resource_request(input),
      parse_tag_resource_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_tag_resource_error(err))
  }
}

fn build_tag_resource_endpoint_params(
  input: TagResourceInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.resource_arn {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke TransactGetItems. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `TransactGetItemsError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `TransactGetItemsErrorTransport` variant.
pub fn transact_get_items(
  client: Client,
  input: TransactGetItemsInput,
) -> Result(TransactGetItemsOutput, TransactGetItemsError) {
  case
    runtime.invoke(
      client.config,
      build_transact_get_items_request(input),
      parse_transact_get_items_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_transact_get_items_error(err))
  }
}

/// Invoke TransactWriteItems. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `TransactWriteItemsError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `TransactWriteItemsErrorTransport` variant.
pub fn transact_write_items(
  client: Client,
  input: TransactWriteItemsInput,
) -> Result(TransactWriteItemsOutput, TransactWriteItemsError) {
  case
    runtime.invoke(
      client.config,
      build_transact_write_items_request(input),
      parse_transact_write_items_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_transact_write_items_error(err))
  }
}

/// Invoke UntagResource. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `UntagResourceError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `UntagResourceErrorTransport` variant.
pub fn untag_resource(
  client: Client,
  input: UntagResourceInput,
) -> Result(UntagResourceOutput, UntagResourceError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_untag_resource_endpoint_params(input),
      build_untag_resource_request(input),
      parse_untag_resource_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_untag_resource_error(err))
  }
}

fn build_untag_resource_endpoint_params(
  input: UntagResourceInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.resource_arn {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke UpdateContinuousBackups. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `UpdateContinuousBackupsError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `UpdateContinuousBackupsErrorTransport` variant.
pub fn update_continuous_backups(
  client: Client,
  input: UpdateContinuousBackupsInput,
) -> Result(UpdateContinuousBackupsOutput, UpdateContinuousBackupsError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_update_continuous_backups_endpoint_params(input),
      build_update_continuous_backups_request(input),
      parse_update_continuous_backups_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_update_continuous_backups_error(err))
  }
}

fn build_update_continuous_backups_endpoint_params(
  input: UpdateContinuousBackupsInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.table_name {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke UpdateContributorInsights. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `UpdateContributorInsightsError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `UpdateContributorInsightsErrorTransport` variant.
pub fn update_contributor_insights(
  client: Client,
  input: UpdateContributorInsightsInput,
) -> Result(UpdateContributorInsightsOutput, UpdateContributorInsightsError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_update_contributor_insights_endpoint_params(input),
      build_update_contributor_insights_request(input),
      parse_update_contributor_insights_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_update_contributor_insights_error(err))
  }
}

fn build_update_contributor_insights_endpoint_params(
  input: UpdateContributorInsightsInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.table_name {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke UpdateGlobalTable. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `UpdateGlobalTableError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `UpdateGlobalTableErrorTransport` variant.
pub fn update_global_table(
  client: Client,
  input: UpdateGlobalTableInput,
) -> Result(UpdateGlobalTableOutput, UpdateGlobalTableError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_update_global_table_endpoint_params(input),
      build_update_global_table_request(input),
      parse_update_global_table_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_update_global_table_error(err))
  }
}

fn build_update_global_table_endpoint_params(
  input: UpdateGlobalTableInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.global_table_name {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke UpdateGlobalTableSettings. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `UpdateGlobalTableSettingsError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `UpdateGlobalTableSettingsErrorTransport` variant.
pub fn update_global_table_settings(
  client: Client,
  input: UpdateGlobalTableSettingsInput,
) -> Result(UpdateGlobalTableSettingsOutput, UpdateGlobalTableSettingsError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_update_global_table_settings_endpoint_params(input),
      build_update_global_table_settings_request(input),
      parse_update_global_table_settings_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_update_global_table_settings_error(err))
  }
}

fn build_update_global_table_settings_endpoint_params(
  input: UpdateGlobalTableSettingsInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.global_table_name {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke UpdateItem. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `UpdateItemError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `UpdateItemErrorTransport` variant.
pub fn update_item(
  client: Client,
  input: UpdateItemInput,
) -> Result(UpdateItemOutput, UpdateItemError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_update_item_endpoint_params(input),
      build_update_item_request(input),
      parse_update_item_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_update_item_error(err))
  }
}

fn build_update_item_endpoint_params(
  input: UpdateItemInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.table_name {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke UpdateKinesisStreamingDestination. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `UpdateKinesisStreamingDestinationError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `UpdateKinesisStreamingDestinationErrorTransport` variant.
pub fn update_kinesis_streaming_destination(
  client: Client,
  input: UpdateKinesisStreamingDestinationInput,
) -> Result(
  UpdateKinesisStreamingDestinationOutput,
  UpdateKinesisStreamingDestinationError,
) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_update_kinesis_streaming_destination_endpoint_params(input),
      build_update_kinesis_streaming_destination_request(input),
      parse_update_kinesis_streaming_destination_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) ->
      Error(translate_update_kinesis_streaming_destination_error(err))
  }
}

fn build_update_kinesis_streaming_destination_endpoint_params(
  input: UpdateKinesisStreamingDestinationInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.table_name {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke UpdateTable. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `UpdateTableError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `UpdateTableErrorTransport` variant.
pub fn update_table(
  client: Client,
  input: UpdateTableInput,
) -> Result(UpdateTableOutput, UpdateTableError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_update_table_endpoint_params(input),
      build_update_table_request(input),
      parse_update_table_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_update_table_error(err))
  }
}

fn build_update_table_endpoint_params(
  input: UpdateTableInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.table_name {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke UpdateTableReplicaAutoScaling. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `UpdateTableReplicaAutoScalingError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `UpdateTableReplicaAutoScalingErrorTransport` variant.
pub fn update_table_replica_auto_scaling(
  client: Client,
  input: UpdateTableReplicaAutoScalingInput,
) -> Result(
  UpdateTableReplicaAutoScalingOutput,
  UpdateTableReplicaAutoScalingError,
) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_update_table_replica_auto_scaling_endpoint_params(input),
      build_update_table_replica_auto_scaling_request(input),
      parse_update_table_replica_auto_scaling_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_update_table_replica_auto_scaling_error(err))
  }
}

fn build_update_table_replica_auto_scaling_endpoint_params(
  input: UpdateTableReplicaAutoScalingInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.table_name {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

/// Invoke UpdateTimeToLive. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `UpdateTimeToLiveError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `UpdateTimeToLiveErrorTransport` variant.
pub fn update_time_to_live(
  client: Client,
  input: UpdateTimeToLiveInput,
) -> Result(UpdateTimeToLiveOutput, UpdateTimeToLiveError) {
  case
    runtime.invoke_with_endpoint_params(
      client.config,
      build_update_time_to_live_endpoint_params(input),
      build_update_time_to_live_request(input),
      parse_update_time_to_live_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_update_time_to_live_error(err))
  }
}

fn build_update_time_to_live_endpoint_params(
  input: UpdateTimeToLiveInput,
) -> dict.Dict(String, endpoints.Value) {
  let params = dict.new()
  let params = case input.table_name {
    option.Some(v) -> dict.insert(params, "ResourceArn", endpoints.StringVal(v))
    option.None -> params
  }
  params
}

pub fn paginate_list_tables(
  client: Client,
  input: ListTablesInput,
  acc: acc,
  reducer: fn(acc, List(String)) -> acc,
) -> Result(acc, ListTablesError) {
  let step = fn(cursor) {
    {
      let input = case cursor {
        option.Some(_) ->
          ListTablesInput(..input, exclusive_start_table_name: cursor)
        option.None -> input
      }
      case list_tables(client, input) {
        Ok(out) ->
          Ok(#(
            option.unwrap(out.table_names, []),
            out.last_evaluated_table_name,
          ))
        Error(e) -> Error(e)
      }
    }
  }
  pagination.fold(acc: acc, step: step, reducer: reducer)
}

pub fn paginate_query(
  client: Client,
  input: QueryInput,
  acc: acc,
  reducer: fn(acc, List(dict.Dict(String, AttributeValue))) -> acc,
) -> Result(acc, QueryError) {
  let step = fn(cursor) {
    {
      let input = case cursor {
        option.Some(_) -> QueryInput(..input, exclusive_start_key: cursor)
        option.None -> input
      }
      case query(client, input) {
        Ok(out) -> Ok(#(option.unwrap(out.items, []), out.last_evaluated_key))
        Error(e) -> Error(e)
      }
    }
  }
  pagination.fold(acc: acc, step: step, reducer: reducer)
}

pub fn paginate_scan(
  client: Client,
  input: ScanInput,
  acc: acc,
  reducer: fn(acc, List(dict.Dict(String, AttributeValue))) -> acc,
) -> Result(acc, ScanError) {
  let step = fn(cursor) {
    {
      let input = case cursor {
        option.Some(_) -> ScanInput(..input, exclusive_start_key: cursor)
        option.None -> input
      }
      case scan(client, input) {
        Ok(out) -> Ok(#(option.unwrap(out.items, []), out.last_evaluated_key))
        Error(e) -> Error(e)
      }
    }
  }
  pagination.fold(acc: acc, step: step, reducer: reducer)
}

pub fn wait_until_table_not_exists(
  client: Client,
  input: DescribeTableInput,
  max_attempts: Int,
) -> Result(Nil, waiter.WaiterError(DescribeTableError)) {
  waiter.wait(
    step: fn(_attempt) {
      {
        case describe_table(client, input) {
          Ok(_) -> waiter.Continue
          Error(e) ->
            case e {
              DescribeTableErrorResourceNotFoundException(_) -> waiter.Settled
              _ -> waiter.Continue
            }
        }
      }
    },
    max_attempts: max_attempts,
    min_delay_ms: 20_000,
    max_delay_ms: 120_000,
  )
}

pub fn parse_internal_server_error_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(headers, body, "InternalServerError")
}

pub fn parse_request_limit_exceeded_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(headers, body, "RequestLimitExceeded")
}

pub fn parse_throttling_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(headers, body, "ThrottlingException")
}

pub fn parse_invalid_endpoint_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(headers, body, "InvalidEndpointException")
}

pub fn parse_provisioned_throughput_exceeded_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(
    headers,
    body,
    "ProvisionedThroughputExceededException",
  )
}

pub fn parse_resource_not_found_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(headers, body, "ResourceNotFoundException")
}

pub fn parse_item_collection_size_limit_exceeded_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(
    headers,
    body,
    "ItemCollectionSizeLimitExceededException",
  )
}

pub fn parse_replicated_write_conflict_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(
    headers,
    body,
    "ReplicatedWriteConflictException",
  )
}

pub fn parse_backup_in_use_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(headers, body, "BackupInUseException")
}

pub fn parse_continuous_backups_unavailable_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(
    headers,
    body,
    "ContinuousBackupsUnavailableException",
  )
}

pub fn parse_limit_exceeded_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(headers, body, "LimitExceededException")
}

pub fn parse_table_in_use_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(headers, body, "TableInUseException")
}

pub fn parse_table_not_found_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(headers, body, "TableNotFoundException")
}

pub fn parse_global_table_already_exists_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(
    headers,
    body,
    "GlobalTableAlreadyExistsException",
  )
}

pub fn parse_resource_in_use_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(headers, body, "ResourceInUseException")
}

pub fn parse_backup_not_found_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(headers, body, "BackupNotFoundException")
}

pub fn parse_conditional_check_failed_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(
    headers,
    body,
    "ConditionalCheckFailedException",
  )
}

pub fn parse_transaction_conflict_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(
    headers,
    body,
    "TransactionConflictException",
  )
}

pub fn parse_policy_not_found_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(headers, body, "PolicyNotFoundException")
}

pub fn parse_export_not_found_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(headers, body, "ExportNotFoundException")
}

pub fn parse_global_table_not_found_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(
    headers,
    body,
    "GlobalTableNotFoundException",
  )
}

pub fn parse_import_not_found_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(headers, body, "ImportNotFoundException")
}

pub fn parse_duplicate_item_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(headers, body, "DuplicateItemException")
}

pub fn parse_idempotent_parameter_mismatch_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(
    headers,
    body,
    "IdempotentParameterMismatchException",
  )
}

pub fn parse_transaction_canceled_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(
    headers,
    body,
    "TransactionCanceledException",
  )
}

pub fn parse_transaction_in_progress_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(
    headers,
    body,
    "TransactionInProgressException",
  )
}

pub fn parse_export_conflict_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(headers, body, "ExportConflictException")
}

pub fn parse_invalid_export_time_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(headers, body, "InvalidExportTimeException")
}

pub fn parse_point_in_time_recovery_unavailable_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(
    headers,
    body,
    "PointInTimeRecoveryUnavailableException",
  )
}

pub fn parse_import_conflict_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(headers, body, "ImportConflictException")
}

pub fn parse_table_already_exists_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(headers, body, "TableAlreadyExistsException")
}

pub fn parse_invalid_restore_time_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(headers, body, "InvalidRestoreTimeException")
}

pub fn parse_replica_already_exists_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(
    headers,
    body,
    "ReplicaAlreadyExistsException",
  )
}

pub fn parse_replica_not_found_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(headers, body, "ReplicaNotFoundException")
}

pub fn parse_index_not_found_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(headers, body, "IndexNotFoundException")
}