//// Generated from com.amazonaws.apigateway#BackplaneControlService (restJson1).
//// 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/codec/rest
import aws/internal/credentials_cache
import aws/internal/http_send
import aws/pagination
import aws/region
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\":{\"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\"},\"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\"}],\"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\":{\"ref\":\"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\":\"UseFIPS\"},true],\"fn\":\"booleanEquals\"},{\"argv\":[{\"ref\":\"UseDualStack\"},true],\"fn\":\"booleanEquals\"}],\"rules\":[{\"conditions\":[{\"argv\":[true,{\"argv\":[{\"ref\":\"PartitionResult\"},\"supportsFIPS\"],\"fn\":\"getAttr\"}],\"fn\":\"booleanEquals\"},{\"argv\":[true,{\"argv\":[{\"ref\":\"PartitionResult\"},\"supportsDualStack\"],\"fn\":\"getAttr\"}],\"fn\":\"booleanEquals\"}],\"rules\":[{\"conditions\":[],\"endpoint\":{\"headers\":{},\"properties\":{},\"url\":\"https://apigateway-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\":[],\"endpoint\":{\"headers\":{},\"properties\":{},\"url\":\"https://apigateway-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\":[true,{\"argv\":[{\"ref\":\"PartitionResult\"},\"supportsDualStack\"],\"fn\":\"getAttr\"}],\"fn\":\"booleanEquals\"}],\"rules\":[{\"conditions\":[],\"endpoint\":{\"headers\":{},\"properties\":{},\"url\":\"https://apigateway.{Region}.{PartitionResult#dualStackDnsSuffix}\"},\"type\":\"endpoint\"}],\"type\":\"tree\"},{\"conditions\":[],\"error\":\"DualStack is enabled but this partition does not support DualStack\",\"type\":\"error\"}],\"type\":\"tree\"},{\"conditions\":[],\"endpoint\":{\"headers\":{},\"properties\":{},\"url\":\"https://apigateway.{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, "apigateway", "apigateway")
  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,
  )
}

/// 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 CreateApiKeyRequest {
  CreateApiKeyRequest(
    customer_id: option.Option(String),
    description: option.Option(String),
    enabled: option.Option(Bool),
    generate_distinct_id: option.Option(Bool),
    name: option.Option(String),
    stage_keys: option.Option(List(StageKey)),
    tags: option.Option(dict.Dict(String, String)),
    value: option.Option(String),
  )
}

pub fn encode_create_api_key_request_struct(
  input: CreateApiKeyRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.customer_id {
    option.Some(v) -> [#("customerId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.description {
    option.Some(v) -> [#("description", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.enabled {
    option.Some(v) -> [#("enabled", json.bool(v)), ..pairs]
    option.None -> [#("enabled", json.bool(False)), ..pairs]
  }
  let pairs = case input.generate_distinct_id {
    option.Some(v) -> [#("generateDistinctId", json.bool(v)), ..pairs]
    option.None -> [#("generateDistinctId", json.bool(False)), ..pairs]
  }
  let pairs = case input.name {
    option.Some(v) -> [#("name", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.stage_keys {
    option.Some(v) -> [
      #("stageKeys", fn(xs) { json.array(xs, encode_stage_key_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.tags {
    option.Some(v) -> [
      #(
        "tags",
        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.value {
    option.Some(v) -> [#("value", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_create_api_key_request_struct() -> decode.Decoder(
  CreateApiKeyRequest,
) {
  use <- decode.recursive
  use customer_id <- decode.optional_field(
    "customerId",
    option.None,
    decode.optional(decode.string),
  )
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use enabled <- decode.optional_field(
    "enabled",
    option.None,
    decode.optional(decode.bool),
  )
  use generate_distinct_id <- decode.optional_field(
    "generateDistinctId",
    option.None,
    decode.optional(decode.bool),
  )
  use name <- decode.optional_field(
    "name",
    option.None,
    decode.optional(decode.string),
  )
  use stage_keys <- decode.optional_field(
    "stageKeys",
    option.None,
    decode.optional(decode.list(decode_stage_key_struct())),
  )
  use tags <- decode.optional_field(
    "tags",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use value <- decode.optional_field(
    "value",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(CreateApiKeyRequest(
    customer_id: customer_id,
    description: description,
    enabled: enabled,
    generate_distinct_id: generate_distinct_id,
    name: name,
    stage_keys: stage_keys,
    tags: tags,
    value: value,
  ))
}

pub fn decode_create_api_key_request_struct_params() -> decode.Decoder(
  CreateApiKeyRequest,
) {
  use <- decode.recursive
  use customer_id <- decode.optional_field(
    "customerId",
    option.None,
    decode.optional(decode.string),
  )
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use enabled <- decode.optional_field(
    "enabled",
    option.None,
    decode.optional(decode.bool),
  )
  use generate_distinct_id <- decode.optional_field(
    "generateDistinctId",
    option.None,
    decode.optional(decode.bool),
  )
  use name <- decode.optional_field(
    "name",
    option.None,
    decode.optional(decode.string),
  )
  use stage_keys <- decode.optional_field(
    "stageKeys",
    option.None,
    decode.optional(decode.list(decode_stage_key_struct_params())),
  )
  use tags <- decode.optional_field(
    "tags",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use value <- decode.optional_field(
    "value",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(CreateApiKeyRequest(
    customer_id: customer_id,
    description: description,
    enabled: enabled,
    generate_distinct_id: generate_distinct_id,
    name: name,
    stage_keys: stage_keys,
    tags: tags,
    value: value,
  ))
}

pub type StageKey {
  StageKey(
    rest_api_id: option.Option(String),
    stage_name: option.Option(String),
  )
}

pub fn encode_stage_key_struct(input: StageKey) -> json.Json {
  let pairs = []
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.stage_name {
    option.Some(v) -> [#("stageName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_stage_key_struct() -> decode.Decoder(StageKey) {
  use <- decode.recursive
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use stage_name <- decode.optional_field(
    "stageName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(StageKey(rest_api_id: rest_api_id, stage_name: stage_name))
}

pub fn decode_stage_key_struct_params() -> decode.Decoder(StageKey) {
  use <- decode.recursive
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use stage_name <- decode.optional_field(
    "stageName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(StageKey(rest_api_id: rest_api_id, stage_name: stage_name))
}

pub type ApiKey {
  ApiKey(
    created_date: option.Option(json_timestamp.Timestamp),
    customer_id: option.Option(String),
    description: option.Option(String),
    enabled: option.Option(Bool),
    id: option.Option(String),
    last_updated_date: option.Option(json_timestamp.Timestamp),
    name: option.Option(String),
    stage_keys: option.Option(List(String)),
    tags: option.Option(dict.Dict(String, String)),
    value: option.Option(String),
  )
}

pub fn encode_api_key_struct(input: ApiKey) -> json.Json {
  let pairs = []
  let pairs = case input.created_date {
    option.Some(v) -> [
      #("createdDate", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.customer_id {
    option.Some(v) -> [#("customerId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.description {
    option.Some(v) -> [#("description", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.enabled {
    option.Some(v) -> [#("enabled", json.bool(v)), ..pairs]
    option.None -> [#("enabled", json.bool(False)), ..pairs]
  }
  let pairs = case input.id {
    option.Some(v) -> [#("id", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.last_updated_date {
    option.Some(v) -> [
      #("lastUpdatedDate", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.name {
    option.Some(v) -> [#("name", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.stage_keys {
    option.Some(v) -> [
      #("stageKeys", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.tags {
    option.Some(v) -> [
      #(
        "tags",
        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.value {
    option.Some(v) -> [#("value", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_api_key_struct() -> decode.Decoder(ApiKey) {
  use <- decode.recursive
  use created_date <- decode.optional_field(
    "createdDate",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use customer_id <- decode.optional_field(
    "customerId",
    option.None,
    decode.optional(decode.string),
  )
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use enabled <- decode.optional_field(
    "enabled",
    option.None,
    decode.optional(decode.bool),
  )
  use id <- decode.optional_field(
    "id",
    option.None,
    decode.optional(decode.string),
  )
  use last_updated_date <- decode.optional_field(
    "lastUpdatedDate",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use name <- decode.optional_field(
    "name",
    option.None,
    decode.optional(decode.string),
  )
  use stage_keys <- decode.optional_field(
    "stageKeys",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  use tags <- decode.optional_field(
    "tags",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use value <- decode.optional_field(
    "value",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ApiKey(
    created_date: created_date,
    customer_id: customer_id,
    description: description,
    enabled: enabled,
    id: id,
    last_updated_date: last_updated_date,
    name: name,
    stage_keys: stage_keys,
    tags: tags,
    value: value,
  ))
}

pub fn decode_api_key_struct_params() -> decode.Decoder(ApiKey) {
  use <- decode.recursive
  use created_date <- decode.optional_field(
    "createdDate",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use customer_id <- decode.optional_field(
    "customerId",
    option.None,
    decode.optional(decode.string),
  )
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use enabled <- decode.optional_field(
    "enabled",
    option.None,
    decode.optional(decode.bool),
  )
  use id <- decode.optional_field(
    "id",
    option.None,
    decode.optional(decode.string),
  )
  use last_updated_date <- decode.optional_field(
    "lastUpdatedDate",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use name <- decode.optional_field(
    "name",
    option.None,
    decode.optional(decode.string),
  )
  use stage_keys <- decode.optional_field(
    "stageKeys",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  use tags <- decode.optional_field(
    "tags",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use value <- decode.optional_field(
    "value",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ApiKey(
    created_date: created_date,
    customer_id: customer_id,
    description: description,
    enabled: enabled,
    id: id,
    last_updated_date: last_updated_date,
    name: name,
    stage_keys: stage_keys,
    tags: tags,
    value: value,
  ))
}

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

pub fn encode_bad_request_exception_struct(
  input: BadRequestException,
) -> 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_bad_request_exception_struct() -> decode.Decoder(
  BadRequestException,
) {
  use <- decode.recursive
  use message <- decode.optional_field(
    "message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(BadRequestException(message: message))
}

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

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

pub fn encode_conflict_exception_struct(input: ConflictException) -> 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_conflict_exception_struct() -> decode.Decoder(ConflictException) {
  use <- decode.recursive
  use message <- decode.optional_field(
    "message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ConflictException(message: message))
}

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

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

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
  }
  let pairs = case input.retry_after_seconds {
    option.Some(v) -> [#("retryAfterSeconds", 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),
  )
  use retry_after_seconds <- decode.optional_field(
    "retryAfterSeconds",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(LimitExceededException(
    message: message,
    retry_after_seconds: retry_after_seconds,
  ))
}

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

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

pub fn encode_not_found_exception_struct(
  input: NotFoundException,
) -> 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_not_found_exception_struct() -> decode.Decoder(NotFoundException) {
  use <- decode.recursive
  use message <- decode.optional_field(
    "message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(NotFoundException(message: message))
}

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

pub type TooManyRequestsException {
  TooManyRequestsException(
    message: option.Option(String),
    retry_after_seconds: option.Option(String),
  )
}

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

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

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

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

pub fn encode_unauthorized_exception_struct(
  input: UnauthorizedException,
) -> 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_unauthorized_exception_struct() -> decode.Decoder(
  UnauthorizedException,
) {
  use <- decode.recursive
  use message <- decode.optional_field(
    "message",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UnauthorizedException(message: message))
}

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

pub type CreateAuthorizerRequest {
  CreateAuthorizerRequest(
    auth_type: option.Option(String),
    authorizer_credentials: option.Option(String),
    authorizer_result_ttl_in_seconds: option.Option(Int),
    authorizer_uri: option.Option(String),
    identity_source: option.Option(String),
    identity_validation_expression: option.Option(String),
    name: option.Option(String),
    provider_ar_ns: option.Option(List(String)),
    rest_api_id: option.Option(String),
    type_: option.Option(AuthorizerType),
  )
}

pub fn encode_create_authorizer_request_struct(
  input: CreateAuthorizerRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.auth_type {
    option.Some(v) -> [#("authType", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.authorizer_credentials {
    option.Some(v) -> [#("authorizerCredentials", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.authorizer_result_ttl_in_seconds {
    option.Some(v) -> [#("authorizerResultTtlInSeconds", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.authorizer_uri {
    option.Some(v) -> [#("authorizerUri", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.identity_source {
    option.Some(v) -> [#("identitySource", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.identity_validation_expression {
    option.Some(v) -> [
      #("identityValidationExpression", json.string(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.name {
    option.Some(v) -> [#("name", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.provider_ar_ns {
    option.Some(v) -> [
      #("providerARNs", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.type_ {
    option.Some(v) -> [#("type", encode_authorizer_type_enum(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_create_authorizer_request_struct() -> decode.Decoder(
  CreateAuthorizerRequest,
) {
  use <- decode.recursive
  use auth_type <- decode.optional_field(
    "authType",
    option.None,
    decode.optional(decode.string),
  )
  use authorizer_credentials <- decode.optional_field(
    "authorizerCredentials",
    option.None,
    decode.optional(decode.string),
  )
  use authorizer_result_ttl_in_seconds <- decode.optional_field(
    "authorizerResultTtlInSeconds",
    option.None,
    decode.optional(decode.int),
  )
  use authorizer_uri <- decode.optional_field(
    "authorizerUri",
    option.None,
    decode.optional(decode.string),
  )
  use identity_source <- decode.optional_field(
    "identitySource",
    option.None,
    decode.optional(decode.string),
  )
  use identity_validation_expression <- decode.optional_field(
    "identityValidationExpression",
    option.None,
    decode.optional(decode.string),
  )
  use name <- decode.optional_field(
    "name",
    option.None,
    decode.optional(decode.string),
  )
  use provider_ar_ns <- decode.optional_field(
    "providerARNs",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use type_ <- decode.optional_field(
    "type",
    option.None,
    decode.optional(decode_authorizer_type_enum()),
  )
  decode.success(CreateAuthorizerRequest(
    auth_type: auth_type,
    authorizer_credentials: authorizer_credentials,
    authorizer_result_ttl_in_seconds: authorizer_result_ttl_in_seconds,
    authorizer_uri: authorizer_uri,
    identity_source: identity_source,
    identity_validation_expression: identity_validation_expression,
    name: name,
    provider_ar_ns: provider_ar_ns,
    rest_api_id: rest_api_id,
    type_: type_,
  ))
}

pub fn decode_create_authorizer_request_struct_params() -> decode.Decoder(
  CreateAuthorizerRequest,
) {
  use <- decode.recursive
  use auth_type <- decode.optional_field(
    "authType",
    option.None,
    decode.optional(decode.string),
  )
  use authorizer_credentials <- decode.optional_field(
    "authorizerCredentials",
    option.None,
    decode.optional(decode.string),
  )
  use authorizer_result_ttl_in_seconds <- decode.optional_field(
    "authorizerResultTtlInSeconds",
    option.None,
    decode.optional(decode.int),
  )
  use authorizer_uri <- decode.optional_field(
    "authorizerUri",
    option.None,
    decode.optional(decode.string),
  )
  use identity_source <- decode.optional_field(
    "identitySource",
    option.None,
    decode.optional(decode.string),
  )
  use identity_validation_expression <- decode.optional_field(
    "identityValidationExpression",
    option.None,
    decode.optional(decode.string),
  )
  use name <- decode.optional_field(
    "name",
    option.None,
    decode.optional(decode.string),
  )
  use provider_ar_ns <- decode.optional_field(
    "providerARNs",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use type_ <- decode.optional_field(
    "type",
    option.None,
    decode.optional(decode_authorizer_type_enum()),
  )
  decode.success(CreateAuthorizerRequest(
    auth_type: auth_type,
    authorizer_credentials: authorizer_credentials,
    authorizer_result_ttl_in_seconds: authorizer_result_ttl_in_seconds,
    authorizer_uri: authorizer_uri,
    identity_source: identity_source,
    identity_validation_expression: identity_validation_expression,
    name: name,
    provider_ar_ns: provider_ar_ns,
    rest_api_id: rest_api_id,
    type_: type_,
  ))
}

pub type AuthorizerType {
  AuthorizerTypeCognitoUserPools
  AuthorizerTypeRequest
  AuthorizerTypeToken
}

pub fn encode_authorizer_type_enum(v: AuthorizerType) -> json.Json {
  case v {
    AuthorizerTypeCognitoUserPools -> json.string("COGNITO_USER_POOLS")
    AuthorizerTypeRequest -> json.string("REQUEST")
    AuthorizerTypeToken -> json.string("TOKEN")
  }
}

pub fn decode_authorizer_type_enum() -> decode.Decoder(AuthorizerType) {
  decode.then(decode.string, fn(s) {
    case s {
      "COGNITO_USER_POOLS" -> decode.success(AuthorizerTypeCognitoUserPools)
      "REQUEST" -> decode.success(AuthorizerTypeRequest)
      "TOKEN" -> decode.success(AuthorizerTypeToken)
      _ -> decode.failure(AuthorizerTypeCognitoUserPools, "unknown enum value")
    }
  })
}

pub fn authorizer_type_from_wire(s: String) -> Result(AuthorizerType, String) {
  case s {
    "COGNITO_USER_POOLS" -> Ok(AuthorizerTypeCognitoUserPools)
    "REQUEST" -> Ok(AuthorizerTypeRequest)
    "TOKEN" -> Ok(AuthorizerTypeToken)
    _ -> Ok(AuthorizerTypeCognitoUserPools)
  }
}

pub type Authorizer {
  Authorizer(
    auth_type: option.Option(String),
    authorizer_credentials: option.Option(String),
    authorizer_result_ttl_in_seconds: option.Option(Int),
    authorizer_uri: option.Option(String),
    id: option.Option(String),
    identity_source: option.Option(String),
    identity_validation_expression: option.Option(String),
    name: option.Option(String),
    provider_ar_ns: option.Option(List(String)),
    type_: option.Option(AuthorizerType),
  )
}

pub fn encode_authorizer_struct(input: Authorizer) -> json.Json {
  let pairs = []
  let pairs = case input.auth_type {
    option.Some(v) -> [#("authType", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.authorizer_credentials {
    option.Some(v) -> [#("authorizerCredentials", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.authorizer_result_ttl_in_seconds {
    option.Some(v) -> [#("authorizerResultTtlInSeconds", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.authorizer_uri {
    option.Some(v) -> [#("authorizerUri", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.id {
    option.Some(v) -> [#("id", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.identity_source {
    option.Some(v) -> [#("identitySource", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.identity_validation_expression {
    option.Some(v) -> [
      #("identityValidationExpression", json.string(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.name {
    option.Some(v) -> [#("name", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.provider_ar_ns {
    option.Some(v) -> [
      #("providerARNs", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.type_ {
    option.Some(v) -> [#("type", encode_authorizer_type_enum(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_authorizer_struct() -> decode.Decoder(Authorizer) {
  use <- decode.recursive
  use auth_type <- decode.optional_field(
    "authType",
    option.None,
    decode.optional(decode.string),
  )
  use authorizer_credentials <- decode.optional_field(
    "authorizerCredentials",
    option.None,
    decode.optional(decode.string),
  )
  use authorizer_result_ttl_in_seconds <- decode.optional_field(
    "authorizerResultTtlInSeconds",
    option.None,
    decode.optional(decode.int),
  )
  use authorizer_uri <- decode.optional_field(
    "authorizerUri",
    option.None,
    decode.optional(decode.string),
  )
  use id <- decode.optional_field(
    "id",
    option.None,
    decode.optional(decode.string),
  )
  use identity_source <- decode.optional_field(
    "identitySource",
    option.None,
    decode.optional(decode.string),
  )
  use identity_validation_expression <- decode.optional_field(
    "identityValidationExpression",
    option.None,
    decode.optional(decode.string),
  )
  use name <- decode.optional_field(
    "name",
    option.None,
    decode.optional(decode.string),
  )
  use provider_ar_ns <- decode.optional_field(
    "providerARNs",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  use type_ <- decode.optional_field(
    "type",
    option.None,
    decode.optional(decode_authorizer_type_enum()),
  )
  decode.success(Authorizer(
    auth_type: auth_type,
    authorizer_credentials: authorizer_credentials,
    authorizer_result_ttl_in_seconds: authorizer_result_ttl_in_seconds,
    authorizer_uri: authorizer_uri,
    id: id,
    identity_source: identity_source,
    identity_validation_expression: identity_validation_expression,
    name: name,
    provider_ar_ns: provider_ar_ns,
    type_: type_,
  ))
}

pub fn decode_authorizer_struct_params() -> decode.Decoder(Authorizer) {
  use <- decode.recursive
  use auth_type <- decode.optional_field(
    "authType",
    option.None,
    decode.optional(decode.string),
  )
  use authorizer_credentials <- decode.optional_field(
    "authorizerCredentials",
    option.None,
    decode.optional(decode.string),
  )
  use authorizer_result_ttl_in_seconds <- decode.optional_field(
    "authorizerResultTtlInSeconds",
    option.None,
    decode.optional(decode.int),
  )
  use authorizer_uri <- decode.optional_field(
    "authorizerUri",
    option.None,
    decode.optional(decode.string),
  )
  use id <- decode.optional_field(
    "id",
    option.None,
    decode.optional(decode.string),
  )
  use identity_source <- decode.optional_field(
    "identitySource",
    option.None,
    decode.optional(decode.string),
  )
  use identity_validation_expression <- decode.optional_field(
    "identityValidationExpression",
    option.None,
    decode.optional(decode.string),
  )
  use name <- decode.optional_field(
    "name",
    option.None,
    decode.optional(decode.string),
  )
  use provider_ar_ns <- decode.optional_field(
    "providerARNs",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  use type_ <- decode.optional_field(
    "type",
    option.None,
    decode.optional(decode_authorizer_type_enum()),
  )
  decode.success(Authorizer(
    auth_type: auth_type,
    authorizer_credentials: authorizer_credentials,
    authorizer_result_ttl_in_seconds: authorizer_result_ttl_in_seconds,
    authorizer_uri: authorizer_uri,
    id: id,
    identity_source: identity_source,
    identity_validation_expression: identity_validation_expression,
    name: name,
    provider_ar_ns: provider_ar_ns,
    type_: type_,
  ))
}

pub type CreateBasePathMappingRequest {
  CreateBasePathMappingRequest(
    base_path: option.Option(String),
    domain_name: option.Option(String),
    domain_name_id: option.Option(String),
    rest_api_id: option.Option(String),
    stage: option.Option(String),
  )
}

pub fn encode_create_base_path_mapping_request_struct(
  input: CreateBasePathMappingRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.base_path {
    option.Some(v) -> [#("basePath", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.domain_name {
    option.Some(v) -> [#("domainName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.domain_name_id {
    option.Some(v) -> [#("domainNameId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.stage {
    option.Some(v) -> [#("stage", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_create_base_path_mapping_request_struct() -> decode.Decoder(
  CreateBasePathMappingRequest,
) {
  use <- decode.recursive
  use base_path <- decode.optional_field(
    "basePath",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name <- decode.optional_field(
    "domainName",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name_id <- decode.optional_field(
    "domainNameId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use stage <- decode.optional_field(
    "stage",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(CreateBasePathMappingRequest(
    base_path: base_path,
    domain_name: domain_name,
    domain_name_id: domain_name_id,
    rest_api_id: rest_api_id,
    stage: stage,
  ))
}

pub fn decode_create_base_path_mapping_request_struct_params() -> decode.Decoder(
  CreateBasePathMappingRequest,
) {
  use <- decode.recursive
  use base_path <- decode.optional_field(
    "basePath",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name <- decode.optional_field(
    "domainName",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name_id <- decode.optional_field(
    "domainNameId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use stage <- decode.optional_field(
    "stage",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(CreateBasePathMappingRequest(
    base_path: base_path,
    domain_name: domain_name,
    domain_name_id: domain_name_id,
    rest_api_id: rest_api_id,
    stage: stage,
  ))
}

pub type BasePathMapping {
  BasePathMapping(
    base_path: option.Option(String),
    rest_api_id: option.Option(String),
    stage: option.Option(String),
  )
}

pub fn encode_base_path_mapping_struct(input: BasePathMapping) -> json.Json {
  let pairs = []
  let pairs = case input.base_path {
    option.Some(v) -> [#("basePath", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.stage {
    option.Some(v) -> [#("stage", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_base_path_mapping_struct() -> decode.Decoder(BasePathMapping) {
  use <- decode.recursive
  use base_path <- decode.optional_field(
    "basePath",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use stage <- decode.optional_field(
    "stage",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(BasePathMapping(
    base_path: base_path,
    rest_api_id: rest_api_id,
    stage: stage,
  ))
}

pub fn decode_base_path_mapping_struct_params() -> decode.Decoder(
  BasePathMapping,
) {
  use <- decode.recursive
  use base_path <- decode.optional_field(
    "basePath",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use stage <- decode.optional_field(
    "stage",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(BasePathMapping(
    base_path: base_path,
    rest_api_id: rest_api_id,
    stage: stage,
  ))
}

pub type CreateDeploymentRequest {
  CreateDeploymentRequest(
    cache_cluster_enabled: option.Option(Bool),
    cache_cluster_size: option.Option(CacheClusterSize),
    canary_settings: option.Option(DeploymentCanarySettings),
    description: option.Option(String),
    rest_api_id: option.Option(String),
    stage_description: option.Option(String),
    stage_name: option.Option(String),
    tracing_enabled: option.Option(Bool),
    variables: option.Option(dict.Dict(String, String)),
  )
}

pub fn encode_create_deployment_request_struct(
  input: CreateDeploymentRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.cache_cluster_enabled {
    option.Some(v) -> [#("cacheClusterEnabled", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.cache_cluster_size {
    option.Some(v) -> [
      #("cacheClusterSize", encode_cache_cluster_size_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.canary_settings {
    option.Some(v) -> [
      #("canarySettings", encode_deployment_canary_settings_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.description {
    option.Some(v) -> [#("description", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.stage_description {
    option.Some(v) -> [#("stageDescription", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.stage_name {
    option.Some(v) -> [#("stageName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.tracing_enabled {
    option.Some(v) -> [#("tracingEnabled", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.variables {
    option.Some(v) -> [
      #(
        "variables",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_create_deployment_request_struct() -> decode.Decoder(
  CreateDeploymentRequest,
) {
  use <- decode.recursive
  use cache_cluster_enabled <- decode.optional_field(
    "cacheClusterEnabled",
    option.None,
    decode.optional(decode.bool),
  )
  use cache_cluster_size <- decode.optional_field(
    "cacheClusterSize",
    option.None,
    decode.optional(decode_cache_cluster_size_enum()),
  )
  use canary_settings <- decode.optional_field(
    "canarySettings",
    option.None,
    decode.optional(decode_deployment_canary_settings_struct()),
  )
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use stage_description <- decode.optional_field(
    "stageDescription",
    option.None,
    decode.optional(decode.string),
  )
  use stage_name <- decode.optional_field(
    "stageName",
    option.None,
    decode.optional(decode.string),
  )
  use tracing_enabled <- decode.optional_field(
    "tracingEnabled",
    option.None,
    decode.optional(decode.bool),
  )
  use variables <- decode.optional_field(
    "variables",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  decode.success(CreateDeploymentRequest(
    cache_cluster_enabled: cache_cluster_enabled,
    cache_cluster_size: cache_cluster_size,
    canary_settings: canary_settings,
    description: description,
    rest_api_id: rest_api_id,
    stage_description: stage_description,
    stage_name: stage_name,
    tracing_enabled: tracing_enabled,
    variables: variables,
  ))
}

pub fn decode_create_deployment_request_struct_params() -> decode.Decoder(
  CreateDeploymentRequest,
) {
  use <- decode.recursive
  use cache_cluster_enabled <- decode.optional_field(
    "cacheClusterEnabled",
    option.None,
    decode.optional(decode.bool),
  )
  use cache_cluster_size <- decode.optional_field(
    "cacheClusterSize",
    option.None,
    decode.optional(decode_cache_cluster_size_enum()),
  )
  use canary_settings <- decode.optional_field(
    "canarySettings",
    option.None,
    decode.optional(decode_deployment_canary_settings_struct_params()),
  )
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use stage_description <- decode.optional_field(
    "stageDescription",
    option.None,
    decode.optional(decode.string),
  )
  use stage_name <- decode.optional_field(
    "stageName",
    option.None,
    decode.optional(decode.string),
  )
  use tracing_enabled <- decode.optional_field(
    "tracingEnabled",
    option.None,
    decode.optional(decode.bool),
  )
  use variables <- decode.optional_field(
    "variables",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  decode.success(CreateDeploymentRequest(
    cache_cluster_enabled: cache_cluster_enabled,
    cache_cluster_size: cache_cluster_size,
    canary_settings: canary_settings,
    description: description,
    rest_api_id: rest_api_id,
    stage_description: stage_description,
    stage_name: stage_name,
    tracing_enabled: tracing_enabled,
    variables: variables,
  ))
}

pub type CacheClusterSize {
  CacheClusterSizeSize0Point5Gb
  CacheClusterSizeSize118Gb
  CacheClusterSizeSize13Point5Gb
  CacheClusterSizeSize1Point6Gb
  CacheClusterSizeSize237Gb
  CacheClusterSizeSize28Point4Gb
  CacheClusterSizeSize58Point2Gb
  CacheClusterSizeSize6Point1Gb
}

pub fn encode_cache_cluster_size_enum(v: CacheClusterSize) -> json.Json {
  case v {
    CacheClusterSizeSize0Point5Gb -> json.string("0.5")
    CacheClusterSizeSize118Gb -> json.string("118")
    CacheClusterSizeSize13Point5Gb -> json.string("13.5")
    CacheClusterSizeSize1Point6Gb -> json.string("1.6")
    CacheClusterSizeSize237Gb -> json.string("237")
    CacheClusterSizeSize28Point4Gb -> json.string("28.4")
    CacheClusterSizeSize58Point2Gb -> json.string("58.2")
    CacheClusterSizeSize6Point1Gb -> json.string("6.1")
  }
}

pub fn decode_cache_cluster_size_enum() -> decode.Decoder(CacheClusterSize) {
  decode.then(decode.string, fn(s) {
    case s {
      "0.5" -> decode.success(CacheClusterSizeSize0Point5Gb)
      "118" -> decode.success(CacheClusterSizeSize118Gb)
      "13.5" -> decode.success(CacheClusterSizeSize13Point5Gb)
      "1.6" -> decode.success(CacheClusterSizeSize1Point6Gb)
      "237" -> decode.success(CacheClusterSizeSize237Gb)
      "28.4" -> decode.success(CacheClusterSizeSize28Point4Gb)
      "58.2" -> decode.success(CacheClusterSizeSize58Point2Gb)
      "6.1" -> decode.success(CacheClusterSizeSize6Point1Gb)
      _ -> decode.failure(CacheClusterSizeSize0Point5Gb, "unknown enum value")
    }
  })
}

pub fn cache_cluster_size_from_wire(
  s: String,
) -> Result(CacheClusterSize, String) {
  case s {
    "0.5" -> Ok(CacheClusterSizeSize0Point5Gb)
    "118" -> Ok(CacheClusterSizeSize118Gb)
    "13.5" -> Ok(CacheClusterSizeSize13Point5Gb)
    "1.6" -> Ok(CacheClusterSizeSize1Point6Gb)
    "237" -> Ok(CacheClusterSizeSize237Gb)
    "28.4" -> Ok(CacheClusterSizeSize28Point4Gb)
    "58.2" -> Ok(CacheClusterSizeSize58Point2Gb)
    "6.1" -> Ok(CacheClusterSizeSize6Point1Gb)
    _ -> Ok(CacheClusterSizeSize0Point5Gb)
  }
}

pub type DeploymentCanarySettings {
  DeploymentCanarySettings(
    percent_traffic: option.Option(json_float.SmithyFloat),
    stage_variable_overrides: option.Option(dict.Dict(String, String)),
    use_stage_cache: option.Option(Bool),
  )
}

pub fn encode_deployment_canary_settings_struct(
  input: DeploymentCanarySettings,
) -> json.Json {
  let pairs = []
  let pairs = case input.percent_traffic {
    option.Some(v) -> [#("percentTraffic", json_float.encode(v)), ..pairs]
    option.None -> [#("percentTraffic", json.int(0)), ..pairs]
  }
  let pairs = case input.stage_variable_overrides {
    option.Some(v) -> [
      #(
        "stageVariableOverrides",
        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.use_stage_cache {
    option.Some(v) -> [#("useStageCache", json.bool(v)), ..pairs]
    option.None -> [#("useStageCache", json.bool(False)), ..pairs]
  }
  json.object(pairs)
}

pub fn decode_deployment_canary_settings_struct() -> decode.Decoder(
  DeploymentCanarySettings,
) {
  use <- decode.recursive
  use percent_traffic <- decode.optional_field(
    "percentTraffic",
    option.None,
    decode.optional(json_float.decoder()),
  )
  use stage_variable_overrides <- decode.optional_field(
    "stageVariableOverrides",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use use_stage_cache <- decode.optional_field(
    "useStageCache",
    option.None,
    decode.optional(decode.bool),
  )
  decode.success(DeploymentCanarySettings(
    percent_traffic: percent_traffic,
    stage_variable_overrides: stage_variable_overrides,
    use_stage_cache: use_stage_cache,
  ))
}

pub fn decode_deployment_canary_settings_struct_params() -> decode.Decoder(
  DeploymentCanarySettings,
) {
  use <- decode.recursive
  use percent_traffic <- decode.optional_field(
    "percentTraffic",
    option.None,
    decode.optional(json_float.decoder()),
  )
  use stage_variable_overrides <- decode.optional_field(
    "stageVariableOverrides",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use use_stage_cache <- decode.optional_field(
    "useStageCache",
    option.None,
    decode.optional(decode.bool),
  )
  decode.success(DeploymentCanarySettings(
    percent_traffic: percent_traffic,
    stage_variable_overrides: stage_variable_overrides,
    use_stage_cache: use_stage_cache,
  ))
}

pub type Deployment {
  Deployment(
    api_summary: option.Option(
      dict.Dict(String, dict.Dict(String, MethodSnapshot)),
    ),
    created_date: option.Option(json_timestamp.Timestamp),
    description: option.Option(String),
    id: option.Option(String),
  )
}

pub fn encode_deployment_struct(input: Deployment) -> json.Json {
  let pairs = []
  let pairs = case input.api_summary {
    option.Some(v) -> [
      #(
        "apiSummary",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(
                pair.0,
                fn(d) {
                  json.object(
                    dict.to_list(d)
                    |> list.map(fn(pair) {
                      #(pair.0, encode_method_snapshot_struct(pair.1))
                    }),
                  )
                }(pair.1),
              )
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.created_date {
    option.Some(v) -> [
      #("createdDate", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.description {
    option.Some(v) -> [#("description", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.id {
    option.Some(v) -> [#("id", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_deployment_struct() -> decode.Decoder(Deployment) {
  use <- decode.recursive
  use api_summary <- decode.optional_field(
    "apiSummary",
    option.None,
    decode.optional(decode.dict(
      decode.string,
      decode.dict(decode.string, decode_method_snapshot_struct()),
    )),
  )
  use created_date <- decode.optional_field(
    "createdDate",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use id <- decode.optional_field(
    "id",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(Deployment(
    api_summary: api_summary,
    created_date: created_date,
    description: description,
    id: id,
  ))
}

pub fn decode_deployment_struct_params() -> decode.Decoder(Deployment) {
  use <- decode.recursive
  use api_summary <- decode.optional_field(
    "apiSummary",
    option.None,
    decode.optional(decode.dict(
      decode.string,
      decode.dict(decode.string, decode_method_snapshot_struct_params()),
    )),
  )
  use created_date <- decode.optional_field(
    "createdDate",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use id <- decode.optional_field(
    "id",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(Deployment(
    api_summary: api_summary,
    created_date: created_date,
    description: description,
    id: id,
  ))
}

pub type MethodSnapshot {
  MethodSnapshot(
    api_key_required: option.Option(Bool),
    authorization_type: option.Option(String),
  )
}

pub fn encode_method_snapshot_struct(input: MethodSnapshot) -> json.Json {
  let pairs = []
  let pairs = case input.api_key_required {
    option.Some(v) -> [#("apiKeyRequired", json.bool(v)), ..pairs]
    option.None -> [#("apiKeyRequired", json.bool(False)), ..pairs]
  }
  let pairs = case input.authorization_type {
    option.Some(v) -> [#("authorizationType", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_method_snapshot_struct() -> decode.Decoder(MethodSnapshot) {
  use <- decode.recursive
  use api_key_required <- decode.optional_field(
    "apiKeyRequired",
    option.None,
    decode.optional(decode.bool),
  )
  use authorization_type <- decode.optional_field(
    "authorizationType",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(MethodSnapshot(
    api_key_required: api_key_required,
    authorization_type: authorization_type,
  ))
}

pub fn decode_method_snapshot_struct_params() -> decode.Decoder(MethodSnapshot) {
  use <- decode.recursive
  use api_key_required <- decode.optional_field(
    "apiKeyRequired",
    option.None,
    decode.optional(decode.bool),
  )
  use authorization_type <- decode.optional_field(
    "authorizationType",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(MethodSnapshot(
    api_key_required: api_key_required,
    authorization_type: authorization_type,
  ))
}

pub type ServiceUnavailableException {
  ServiceUnavailableException(
    message: option.Option(String),
    retry_after_seconds: option.Option(String),
  )
}

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

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

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

pub type CreateDocumentationPartRequest {
  CreateDocumentationPartRequest(
    location: option.Option(DocumentationPartLocation),
    properties: option.Option(String),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_create_documentation_part_request_struct(
  input: CreateDocumentationPartRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.location {
    option.Some(v) -> [
      #("location", encode_documentation_part_location_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.properties {
    option.Some(v) -> [#("properties", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_create_documentation_part_request_struct() -> decode.Decoder(
  CreateDocumentationPartRequest,
) {
  use <- decode.recursive
  use location <- decode.optional_field(
    "location",
    option.None,
    decode.optional(decode_documentation_part_location_struct()),
  )
  use properties <- decode.optional_field(
    "properties",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(CreateDocumentationPartRequest(
    location: location,
    properties: properties,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_create_documentation_part_request_struct_params() -> decode.Decoder(
  CreateDocumentationPartRequest,
) {
  use <- decode.recursive
  use location <- decode.optional_field(
    "location",
    option.None,
    decode.optional(decode_documentation_part_location_struct_params()),
  )
  use properties <- decode.optional_field(
    "properties",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(CreateDocumentationPartRequest(
    location: location,
    properties: properties,
    rest_api_id: rest_api_id,
  ))
}

pub type DocumentationPartLocation {
  DocumentationPartLocation(
    method: option.Option(String),
    name: option.Option(String),
    path: option.Option(String),
    status_code: option.Option(String),
    type_: option.Option(DocumentationPartType),
  )
}

pub fn encode_documentation_part_location_struct(
  input: DocumentationPartLocation,
) -> json.Json {
  let pairs = []
  let pairs = case input.method {
    option.Some(v) -> [#("method", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.name {
    option.Some(v) -> [#("name", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.path {
    option.Some(v) -> [#("path", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.status_code {
    option.Some(v) -> [#("statusCode", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.type_ {
    option.Some(v) -> [
      #("type", encode_documentation_part_type_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_documentation_part_location_struct() -> decode.Decoder(
  DocumentationPartLocation,
) {
  use <- decode.recursive
  use method <- decode.optional_field(
    "method",
    option.None,
    decode.optional(decode.string),
  )
  use name <- decode.optional_field(
    "name",
    option.None,
    decode.optional(decode.string),
  )
  use path <- decode.optional_field(
    "path",
    option.None,
    decode.optional(decode.string),
  )
  use status_code <- decode.optional_field(
    "statusCode",
    option.None,
    decode.optional(decode.string),
  )
  use type_ <- decode.optional_field(
    "type",
    option.None,
    decode.optional(decode_documentation_part_type_enum()),
  )
  decode.success(DocumentationPartLocation(
    method: method,
    name: name,
    path: path,
    status_code: status_code,
    type_: type_,
  ))
}

pub fn decode_documentation_part_location_struct_params() -> decode.Decoder(
  DocumentationPartLocation,
) {
  use <- decode.recursive
  use method <- decode.optional_field(
    "method",
    option.None,
    decode.optional(decode.string),
  )
  use name <- decode.optional_field(
    "name",
    option.None,
    decode.optional(decode.string),
  )
  use path <- decode.optional_field(
    "path",
    option.None,
    decode.optional(decode.string),
  )
  use status_code <- decode.optional_field(
    "statusCode",
    option.None,
    decode.optional(decode.string),
  )
  use type_ <- decode.optional_field(
    "type",
    option.None,
    decode.optional(decode_documentation_part_type_enum()),
  )
  decode.success(DocumentationPartLocation(
    method: method,
    name: name,
    path: path,
    status_code: status_code,
    type_: type_,
  ))
}

pub type DocumentationPartType {
  DocumentationPartTypeApi
  DocumentationPartTypeAuthorizer
  DocumentationPartTypeMethod
  DocumentationPartTypeModel
  DocumentationPartTypePathParameter
  DocumentationPartTypeQueryParameter
  DocumentationPartTypeRequestBody
  DocumentationPartTypeRequestHeader
  DocumentationPartTypeResource
  DocumentationPartTypeResponse
  DocumentationPartTypeResponseBody
  DocumentationPartTypeResponseHeader
}

pub fn encode_documentation_part_type_enum(
  v: DocumentationPartType,
) -> json.Json {
  case v {
    DocumentationPartTypeApi -> json.string("API")
    DocumentationPartTypeAuthorizer -> json.string("AUTHORIZER")
    DocumentationPartTypeMethod -> json.string("METHOD")
    DocumentationPartTypeModel -> json.string("MODEL")
    DocumentationPartTypePathParameter -> json.string("PATH_PARAMETER")
    DocumentationPartTypeQueryParameter -> json.string("QUERY_PARAMETER")
    DocumentationPartTypeRequestBody -> json.string("REQUEST_BODY")
    DocumentationPartTypeRequestHeader -> json.string("REQUEST_HEADER")
    DocumentationPartTypeResource -> json.string("RESOURCE")
    DocumentationPartTypeResponse -> json.string("RESPONSE")
    DocumentationPartTypeResponseBody -> json.string("RESPONSE_BODY")
    DocumentationPartTypeResponseHeader -> json.string("RESPONSE_HEADER")
  }
}

pub fn decode_documentation_part_type_enum() -> decode.Decoder(
  DocumentationPartType,
) {
  decode.then(decode.string, fn(s) {
    case s {
      "API" -> decode.success(DocumentationPartTypeApi)
      "AUTHORIZER" -> decode.success(DocumentationPartTypeAuthorizer)
      "METHOD" -> decode.success(DocumentationPartTypeMethod)
      "MODEL" -> decode.success(DocumentationPartTypeModel)
      "PATH_PARAMETER" -> decode.success(DocumentationPartTypePathParameter)
      "QUERY_PARAMETER" -> decode.success(DocumentationPartTypeQueryParameter)
      "REQUEST_BODY" -> decode.success(DocumentationPartTypeRequestBody)
      "REQUEST_HEADER" -> decode.success(DocumentationPartTypeRequestHeader)
      "RESOURCE" -> decode.success(DocumentationPartTypeResource)
      "RESPONSE" -> decode.success(DocumentationPartTypeResponse)
      "RESPONSE_BODY" -> decode.success(DocumentationPartTypeResponseBody)
      "RESPONSE_HEADER" -> decode.success(DocumentationPartTypeResponseHeader)
      _ -> decode.failure(DocumentationPartTypeApi, "unknown enum value")
    }
  })
}

pub fn documentation_part_type_from_wire(
  s: String,
) -> Result(DocumentationPartType, String) {
  case s {
    "API" -> Ok(DocumentationPartTypeApi)
    "AUTHORIZER" -> Ok(DocumentationPartTypeAuthorizer)
    "METHOD" -> Ok(DocumentationPartTypeMethod)
    "MODEL" -> Ok(DocumentationPartTypeModel)
    "PATH_PARAMETER" -> Ok(DocumentationPartTypePathParameter)
    "QUERY_PARAMETER" -> Ok(DocumentationPartTypeQueryParameter)
    "REQUEST_BODY" -> Ok(DocumentationPartTypeRequestBody)
    "REQUEST_HEADER" -> Ok(DocumentationPartTypeRequestHeader)
    "RESOURCE" -> Ok(DocumentationPartTypeResource)
    "RESPONSE" -> Ok(DocumentationPartTypeResponse)
    "RESPONSE_BODY" -> Ok(DocumentationPartTypeResponseBody)
    "RESPONSE_HEADER" -> Ok(DocumentationPartTypeResponseHeader)
    _ -> Ok(DocumentationPartTypeApi)
  }
}

pub type DocumentationPart {
  DocumentationPart(
    id: option.Option(String),
    location: option.Option(DocumentationPartLocation),
    properties: option.Option(String),
  )
}

pub fn encode_documentation_part_struct(input: DocumentationPart) -> json.Json {
  let pairs = []
  let pairs = case input.id {
    option.Some(v) -> [#("id", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.location {
    option.Some(v) -> [
      #("location", encode_documentation_part_location_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.properties {
    option.Some(v) -> [#("properties", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_documentation_part_struct() -> decode.Decoder(DocumentationPart) {
  use <- decode.recursive
  use id <- decode.optional_field(
    "id",
    option.None,
    decode.optional(decode.string),
  )
  use location <- decode.optional_field(
    "location",
    option.None,
    decode.optional(decode_documentation_part_location_struct()),
  )
  use properties <- decode.optional_field(
    "properties",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DocumentationPart(
    id: id,
    location: location,
    properties: properties,
  ))
}

pub fn decode_documentation_part_struct_params() -> decode.Decoder(
  DocumentationPart,
) {
  use <- decode.recursive
  use id <- decode.optional_field(
    "id",
    option.None,
    decode.optional(decode.string),
  )
  use location <- decode.optional_field(
    "location",
    option.None,
    decode.optional(decode_documentation_part_location_struct_params()),
  )
  use properties <- decode.optional_field(
    "properties",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DocumentationPart(
    id: id,
    location: location,
    properties: properties,
  ))
}

pub type CreateDocumentationVersionRequest {
  CreateDocumentationVersionRequest(
    description: option.Option(String),
    documentation_version: option.Option(String),
    rest_api_id: option.Option(String),
    stage_name: option.Option(String),
  )
}

pub fn encode_create_documentation_version_request_struct(
  input: CreateDocumentationVersionRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.description {
    option.Some(v) -> [#("description", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.documentation_version {
    option.Some(v) -> [#("documentationVersion", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.stage_name {
    option.Some(v) -> [#("stageName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_create_documentation_version_request_struct() -> decode.Decoder(
  CreateDocumentationVersionRequest,
) {
  use <- decode.recursive
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use documentation_version <- decode.optional_field(
    "documentationVersion",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use stage_name <- decode.optional_field(
    "stageName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(CreateDocumentationVersionRequest(
    description: description,
    documentation_version: documentation_version,
    rest_api_id: rest_api_id,
    stage_name: stage_name,
  ))
}

pub fn decode_create_documentation_version_request_struct_params() -> decode.Decoder(
  CreateDocumentationVersionRequest,
) {
  use <- decode.recursive
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use documentation_version <- decode.optional_field(
    "documentationVersion",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use stage_name <- decode.optional_field(
    "stageName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(CreateDocumentationVersionRequest(
    description: description,
    documentation_version: documentation_version,
    rest_api_id: rest_api_id,
    stage_name: stage_name,
  ))
}

pub type DocumentationVersion {
  DocumentationVersion(
    created_date: option.Option(json_timestamp.Timestamp),
    description: option.Option(String),
    version: option.Option(String),
  )
}

pub fn encode_documentation_version_struct(
  input: DocumentationVersion,
) -> json.Json {
  let pairs = []
  let pairs = case input.created_date {
    option.Some(v) -> [
      #("createdDate", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.description {
    option.Some(v) -> [#("description", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.version {
    option.Some(v) -> [#("version", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_documentation_version_struct() -> decode.Decoder(
  DocumentationVersion,
) {
  use <- decode.recursive
  use created_date <- decode.optional_field(
    "createdDate",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use version <- decode.optional_field(
    "version",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DocumentationVersion(
    created_date: created_date,
    description: description,
    version: version,
  ))
}

pub fn decode_documentation_version_struct_params() -> decode.Decoder(
  DocumentationVersion,
) {
  use <- decode.recursive
  use created_date <- decode.optional_field(
    "createdDate",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use version <- decode.optional_field(
    "version",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DocumentationVersion(
    created_date: created_date,
    description: description,
    version: version,
  ))
}

pub type CreateDomainNameRequest {
  CreateDomainNameRequest(
    certificate_arn: option.Option(String),
    certificate_body: option.Option(String),
    certificate_chain: option.Option(String),
    certificate_name: option.Option(String),
    certificate_private_key: option.Option(String),
    domain_name: option.Option(String),
    endpoint_access_mode: option.Option(EndpointAccessMode),
    endpoint_configuration: option.Option(EndpointConfiguration),
    mutual_tls_authentication: option.Option(MutualTlsAuthenticationInput),
    ownership_verification_certificate_arn: option.Option(String),
    policy: option.Option(String),
    regional_certificate_arn: option.Option(String),
    regional_certificate_name: option.Option(String),
    routing_mode: option.Option(RoutingMode),
    security_policy: option.Option(SecurityPolicy),
    tags: option.Option(dict.Dict(String, String)),
  )
}

pub fn encode_create_domain_name_request_struct(
  input: CreateDomainNameRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.certificate_arn {
    option.Some(v) -> [#("certificateArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.certificate_body {
    option.Some(v) -> [#("certificateBody", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.certificate_chain {
    option.Some(v) -> [#("certificateChain", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.certificate_name {
    option.Some(v) -> [#("certificateName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.certificate_private_key {
    option.Some(v) -> [#("certificatePrivateKey", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.domain_name {
    option.Some(v) -> [#("domainName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.endpoint_access_mode {
    option.Some(v) -> [
      #("endpointAccessMode", encode_endpoint_access_mode_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.endpoint_configuration {
    option.Some(v) -> [
      #("endpointConfiguration", encode_endpoint_configuration_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.mutual_tls_authentication {
    option.Some(v) -> [
      #(
        "mutualTlsAuthentication",
        encode_mutual_tls_authentication_input_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.ownership_verification_certificate_arn {
    option.Some(v) -> [
      #("ownershipVerificationCertificateArn", 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.regional_certificate_arn {
    option.Some(v) -> [#("regionalCertificateArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.regional_certificate_name {
    option.Some(v) -> [#("regionalCertificateName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.routing_mode {
    option.Some(v) -> [#("routingMode", encode_routing_mode_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.security_policy {
    option.Some(v) -> [
      #("securityPolicy", encode_security_policy_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.tags {
    option.Some(v) -> [
      #(
        "tags",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_create_domain_name_request_struct() -> decode.Decoder(
  CreateDomainNameRequest,
) {
  use <- decode.recursive
  use certificate_arn <- decode.optional_field(
    "certificateArn",
    option.None,
    decode.optional(decode.string),
  )
  use certificate_body <- decode.optional_field(
    "certificateBody",
    option.None,
    decode.optional(decode.string),
  )
  use certificate_chain <- decode.optional_field(
    "certificateChain",
    option.None,
    decode.optional(decode.string),
  )
  use certificate_name <- decode.optional_field(
    "certificateName",
    option.None,
    decode.optional(decode.string),
  )
  use certificate_private_key <- decode.optional_field(
    "certificatePrivateKey",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name <- decode.optional_field(
    "domainName",
    option.None,
    decode.optional(decode.string),
  )
  use endpoint_access_mode <- decode.optional_field(
    "endpointAccessMode",
    option.None,
    decode.optional(decode_endpoint_access_mode_enum()),
  )
  use endpoint_configuration <- decode.optional_field(
    "endpointConfiguration",
    option.None,
    decode.optional(decode_endpoint_configuration_struct()),
  )
  use mutual_tls_authentication <- decode.optional_field(
    "mutualTlsAuthentication",
    option.None,
    decode.optional(decode_mutual_tls_authentication_input_struct()),
  )
  use ownership_verification_certificate_arn <- decode.optional_field(
    "ownershipVerificationCertificateArn",
    option.None,
    decode.optional(decode.string),
  )
  use policy <- decode.optional_field(
    "policy",
    option.None,
    decode.optional(decode.string),
  )
  use regional_certificate_arn <- decode.optional_field(
    "regionalCertificateArn",
    option.None,
    decode.optional(decode.string),
  )
  use regional_certificate_name <- decode.optional_field(
    "regionalCertificateName",
    option.None,
    decode.optional(decode.string),
  )
  use routing_mode <- decode.optional_field(
    "routingMode",
    option.None,
    decode.optional(decode_routing_mode_enum()),
  )
  use security_policy <- decode.optional_field(
    "securityPolicy",
    option.None,
    decode.optional(decode_security_policy_enum()),
  )
  use tags <- decode.optional_field(
    "tags",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  decode.success(CreateDomainNameRequest(
    certificate_arn: certificate_arn,
    certificate_body: certificate_body,
    certificate_chain: certificate_chain,
    certificate_name: certificate_name,
    certificate_private_key: certificate_private_key,
    domain_name: domain_name,
    endpoint_access_mode: endpoint_access_mode,
    endpoint_configuration: endpoint_configuration,
    mutual_tls_authentication: mutual_tls_authentication,
    ownership_verification_certificate_arn: ownership_verification_certificate_arn,
    policy: policy,
    regional_certificate_arn: regional_certificate_arn,
    regional_certificate_name: regional_certificate_name,
    routing_mode: routing_mode,
    security_policy: security_policy,
    tags: tags,
  ))
}

pub fn decode_create_domain_name_request_struct_params() -> decode.Decoder(
  CreateDomainNameRequest,
) {
  use <- decode.recursive
  use certificate_arn <- decode.optional_field(
    "certificateArn",
    option.None,
    decode.optional(decode.string),
  )
  use certificate_body <- decode.optional_field(
    "certificateBody",
    option.None,
    decode.optional(decode.string),
  )
  use certificate_chain <- decode.optional_field(
    "certificateChain",
    option.None,
    decode.optional(decode.string),
  )
  use certificate_name <- decode.optional_field(
    "certificateName",
    option.None,
    decode.optional(decode.string),
  )
  use certificate_private_key <- decode.optional_field(
    "certificatePrivateKey",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name <- decode.optional_field(
    "domainName",
    option.None,
    decode.optional(decode.string),
  )
  use endpoint_access_mode <- decode.optional_field(
    "endpointAccessMode",
    option.None,
    decode.optional(decode_endpoint_access_mode_enum()),
  )
  use endpoint_configuration <- decode.optional_field(
    "endpointConfiguration",
    option.None,
    decode.optional(decode_endpoint_configuration_struct_params()),
  )
  use mutual_tls_authentication <- decode.optional_field(
    "mutualTlsAuthentication",
    option.None,
    decode.optional(decode_mutual_tls_authentication_input_struct_params()),
  )
  use ownership_verification_certificate_arn <- decode.optional_field(
    "ownershipVerificationCertificateArn",
    option.None,
    decode.optional(decode.string),
  )
  use policy <- decode.optional_field(
    "policy",
    option.None,
    decode.optional(decode.string),
  )
  use regional_certificate_arn <- decode.optional_field(
    "regionalCertificateArn",
    option.None,
    decode.optional(decode.string),
  )
  use regional_certificate_name <- decode.optional_field(
    "regionalCertificateName",
    option.None,
    decode.optional(decode.string),
  )
  use routing_mode <- decode.optional_field(
    "routingMode",
    option.None,
    decode.optional(decode_routing_mode_enum()),
  )
  use security_policy <- decode.optional_field(
    "securityPolicy",
    option.None,
    decode.optional(decode_security_policy_enum()),
  )
  use tags <- decode.optional_field(
    "tags",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  decode.success(CreateDomainNameRequest(
    certificate_arn: certificate_arn,
    certificate_body: certificate_body,
    certificate_chain: certificate_chain,
    certificate_name: certificate_name,
    certificate_private_key: certificate_private_key,
    domain_name: domain_name,
    endpoint_access_mode: endpoint_access_mode,
    endpoint_configuration: endpoint_configuration,
    mutual_tls_authentication: mutual_tls_authentication,
    ownership_verification_certificate_arn: ownership_verification_certificate_arn,
    policy: policy,
    regional_certificate_arn: regional_certificate_arn,
    regional_certificate_name: regional_certificate_name,
    routing_mode: routing_mode,
    security_policy: security_policy,
    tags: tags,
  ))
}

pub type EndpointAccessMode {
  EndpointAccessModeBasic
  EndpointAccessModeStrict
}

pub fn encode_endpoint_access_mode_enum(v: EndpointAccessMode) -> json.Json {
  case v {
    EndpointAccessModeBasic -> json.string("BASIC")
    EndpointAccessModeStrict -> json.string("STRICT")
  }
}

pub fn decode_endpoint_access_mode_enum() -> decode.Decoder(EndpointAccessMode) {
  decode.then(decode.string, fn(s) {
    case s {
      "BASIC" -> decode.success(EndpointAccessModeBasic)
      "STRICT" -> decode.success(EndpointAccessModeStrict)
      _ -> decode.failure(EndpointAccessModeBasic, "unknown enum value")
    }
  })
}

pub fn endpoint_access_mode_from_wire(
  s: String,
) -> Result(EndpointAccessMode, String) {
  case s {
    "BASIC" -> Ok(EndpointAccessModeBasic)
    "STRICT" -> Ok(EndpointAccessModeStrict)
    _ -> Ok(EndpointAccessModeBasic)
  }
}

pub type EndpointConfiguration {
  EndpointConfiguration(
    ip_address_type: option.Option(IpAddressType),
    types: option.Option(List(EndpointType)),
    vpc_endpoint_ids: option.Option(List(String)),
  )
}

pub fn encode_endpoint_configuration_struct(
  input: EndpointConfiguration,
) -> json.Json {
  let pairs = []
  let pairs = case input.ip_address_type {
    option.Some(v) -> [
      #("ipAddressType", encode_ip_address_type_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.types {
    option.Some(v) -> [
      #("types", fn(xs) { json.array(xs, encode_endpoint_type_enum) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.vpc_endpoint_ids {
    option.Some(v) -> [
      #("vpcEndpointIds", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_endpoint_configuration_struct() -> decode.Decoder(
  EndpointConfiguration,
) {
  use <- decode.recursive
  use ip_address_type <- decode.optional_field(
    "ipAddressType",
    option.None,
    decode.optional(decode_ip_address_type_enum()),
  )
  use types <- decode.optional_field(
    "types",
    option.None,
    decode.optional(decode.list(decode_endpoint_type_enum())),
  )
  use vpc_endpoint_ids <- decode.optional_field(
    "vpcEndpointIds",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  decode.success(EndpointConfiguration(
    ip_address_type: ip_address_type,
    types: types,
    vpc_endpoint_ids: vpc_endpoint_ids,
  ))
}

pub fn decode_endpoint_configuration_struct_params() -> decode.Decoder(
  EndpointConfiguration,
) {
  use <- decode.recursive
  use ip_address_type <- decode.optional_field(
    "ipAddressType",
    option.None,
    decode.optional(decode_ip_address_type_enum()),
  )
  use types <- decode.optional_field(
    "types",
    option.None,
    decode.optional(decode.list(decode_endpoint_type_enum())),
  )
  use vpc_endpoint_ids <- decode.optional_field(
    "vpcEndpointIds",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  decode.success(EndpointConfiguration(
    ip_address_type: ip_address_type,
    types: types,
    vpc_endpoint_ids: vpc_endpoint_ids,
  ))
}

pub type IpAddressType {
  IpAddressTypeDualstack
  IpAddressTypeIpv4
}

pub fn encode_ip_address_type_enum(v: IpAddressType) -> json.Json {
  case v {
    IpAddressTypeDualstack -> json.string("dualstack")
    IpAddressTypeIpv4 -> json.string("ipv4")
  }
}

pub fn decode_ip_address_type_enum() -> decode.Decoder(IpAddressType) {
  decode.then(decode.string, fn(s) {
    case s {
      "dualstack" -> decode.success(IpAddressTypeDualstack)
      "ipv4" -> decode.success(IpAddressTypeIpv4)
      _ -> decode.failure(IpAddressTypeDualstack, "unknown enum value")
    }
  })
}

pub fn ip_address_type_from_wire(s: String) -> Result(IpAddressType, String) {
  case s {
    "dualstack" -> Ok(IpAddressTypeDualstack)
    "ipv4" -> Ok(IpAddressTypeIpv4)
    _ -> Ok(IpAddressTypeDualstack)
  }
}

pub type EndpointType {
  EndpointTypeEdge
  EndpointTypePrivate
  EndpointTypeRegional
}

pub fn encode_endpoint_type_enum(v: EndpointType) -> json.Json {
  case v {
    EndpointTypeEdge -> json.string("EDGE")
    EndpointTypePrivate -> json.string("PRIVATE")
    EndpointTypeRegional -> json.string("REGIONAL")
  }
}

pub fn decode_endpoint_type_enum() -> decode.Decoder(EndpointType) {
  decode.then(decode.string, fn(s) {
    case s {
      "EDGE" -> decode.success(EndpointTypeEdge)
      "PRIVATE" -> decode.success(EndpointTypePrivate)
      "REGIONAL" -> decode.success(EndpointTypeRegional)
      _ -> decode.failure(EndpointTypeEdge, "unknown enum value")
    }
  })
}

pub fn endpoint_type_from_wire(s: String) -> Result(EndpointType, String) {
  case s {
    "EDGE" -> Ok(EndpointTypeEdge)
    "PRIVATE" -> Ok(EndpointTypePrivate)
    "REGIONAL" -> Ok(EndpointTypeRegional)
    _ -> Ok(EndpointTypeEdge)
  }
}

pub type MutualTlsAuthenticationInput {
  MutualTlsAuthenticationInput(
    truststore_uri: option.Option(String),
    truststore_version: option.Option(String),
  )
}

pub fn encode_mutual_tls_authentication_input_struct(
  input: MutualTlsAuthenticationInput,
) -> json.Json {
  let pairs = []
  let pairs = case input.truststore_uri {
    option.Some(v) -> [#("truststoreUri", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.truststore_version {
    option.Some(v) -> [#("truststoreVersion", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_mutual_tls_authentication_input_struct() -> decode.Decoder(
  MutualTlsAuthenticationInput,
) {
  use <- decode.recursive
  use truststore_uri <- decode.optional_field(
    "truststoreUri",
    option.None,
    decode.optional(decode.string),
  )
  use truststore_version <- decode.optional_field(
    "truststoreVersion",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(MutualTlsAuthenticationInput(
    truststore_uri: truststore_uri,
    truststore_version: truststore_version,
  ))
}

pub fn decode_mutual_tls_authentication_input_struct_params() -> decode.Decoder(
  MutualTlsAuthenticationInput,
) {
  use <- decode.recursive
  use truststore_uri <- decode.optional_field(
    "truststoreUri",
    option.None,
    decode.optional(decode.string),
  )
  use truststore_version <- decode.optional_field(
    "truststoreVersion",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(MutualTlsAuthenticationInput(
    truststore_uri: truststore_uri,
    truststore_version: truststore_version,
  ))
}

pub type RoutingMode {
  RoutingModeBasePathMappingOnly
  RoutingModeRoutingRuleOnly
  RoutingModeRoutingRuleThenBasePathMapping
}

pub fn encode_routing_mode_enum(v: RoutingMode) -> json.Json {
  case v {
    RoutingModeBasePathMappingOnly -> json.string("BASE_PATH_MAPPING_ONLY")
    RoutingModeRoutingRuleOnly -> json.string("ROUTING_RULE_ONLY")
    RoutingModeRoutingRuleThenBasePathMapping ->
      json.string("ROUTING_RULE_THEN_BASE_PATH_MAPPING")
  }
}

pub fn decode_routing_mode_enum() -> decode.Decoder(RoutingMode) {
  decode.then(decode.string, fn(s) {
    case s {
      "BASE_PATH_MAPPING_ONLY" -> decode.success(RoutingModeBasePathMappingOnly)
      "ROUTING_RULE_ONLY" -> decode.success(RoutingModeRoutingRuleOnly)
      "ROUTING_RULE_THEN_BASE_PATH_MAPPING" ->
        decode.success(RoutingModeRoutingRuleThenBasePathMapping)
      _ -> decode.failure(RoutingModeBasePathMappingOnly, "unknown enum value")
    }
  })
}

pub fn routing_mode_from_wire(s: String) -> Result(RoutingMode, String) {
  case s {
    "BASE_PATH_MAPPING_ONLY" -> Ok(RoutingModeBasePathMappingOnly)
    "ROUTING_RULE_ONLY" -> Ok(RoutingModeRoutingRuleOnly)
    "ROUTING_RULE_THEN_BASE_PATH_MAPPING" ->
      Ok(RoutingModeRoutingRuleThenBasePathMapping)
    _ -> Ok(RoutingModeBasePathMappingOnly)
  }
}

pub type SecurityPolicy {
  SecurityPolicySecuritypolicyTls122018Edge
  SecurityPolicySecuritypolicyTls12Pfs2025Edge
  SecurityPolicySecuritypolicyTls1312202106
  SecurityPolicySecuritypolicyTls1312FipsPfsPq202509
  SecurityPolicySecuritypolicyTls1312FipsPq202509
  SecurityPolicySecuritypolicyTls1312PfsPq202509
  SecurityPolicySecuritypolicyTls1312Pq202509
  SecurityPolicySecuritypolicyTls1313202509
  SecurityPolicySecuritypolicyTls1313Fips202509
  SecurityPolicySecuritypolicyTls132025Edge
  SecurityPolicyTls10
  SecurityPolicyTls12
}

pub fn encode_security_policy_enum(v: SecurityPolicy) -> json.Json {
  case v {
    SecurityPolicySecuritypolicyTls122018Edge ->
      json.string("SecurityPolicy_TLS12_2018_EDGE")
    SecurityPolicySecuritypolicyTls12Pfs2025Edge ->
      json.string("SecurityPolicy_TLS12_PFS_2025_EDGE")
    SecurityPolicySecuritypolicyTls1312202106 ->
      json.string("SecurityPolicy_TLS13_1_2_2021_06")
    SecurityPolicySecuritypolicyTls1312FipsPfsPq202509 ->
      json.string("SecurityPolicy_TLS13_1_2_FIPS_PFS_PQ_2025_09")
    SecurityPolicySecuritypolicyTls1312FipsPq202509 ->
      json.string("SecurityPolicy_TLS13_1_2_FIPS_PQ_2025_09")
    SecurityPolicySecuritypolicyTls1312PfsPq202509 ->
      json.string("SecurityPolicy_TLS13_1_2_PFS_PQ_2025_09")
    SecurityPolicySecuritypolicyTls1312Pq202509 ->
      json.string("SecurityPolicy_TLS13_1_2_PQ_2025_09")
    SecurityPolicySecuritypolicyTls1313202509 ->
      json.string("SecurityPolicy_TLS13_1_3_2025_09")
    SecurityPolicySecuritypolicyTls1313Fips202509 ->
      json.string("SecurityPolicy_TLS13_1_3_FIPS_2025_09")
    SecurityPolicySecuritypolicyTls132025Edge ->
      json.string("SecurityPolicy_TLS13_2025_EDGE")
    SecurityPolicyTls10 -> json.string("TLS_1_0")
    SecurityPolicyTls12 -> json.string("TLS_1_2")
  }
}

pub fn decode_security_policy_enum() -> decode.Decoder(SecurityPolicy) {
  decode.then(decode.string, fn(s) {
    case s {
      "SecurityPolicy_TLS12_2018_EDGE" ->
        decode.success(SecurityPolicySecuritypolicyTls122018Edge)
      "SecurityPolicy_TLS12_PFS_2025_EDGE" ->
        decode.success(SecurityPolicySecuritypolicyTls12Pfs2025Edge)
      "SecurityPolicy_TLS13_1_2_2021_06" ->
        decode.success(SecurityPolicySecuritypolicyTls1312202106)
      "SecurityPolicy_TLS13_1_2_FIPS_PFS_PQ_2025_09" ->
        decode.success(SecurityPolicySecuritypolicyTls1312FipsPfsPq202509)
      "SecurityPolicy_TLS13_1_2_FIPS_PQ_2025_09" ->
        decode.success(SecurityPolicySecuritypolicyTls1312FipsPq202509)
      "SecurityPolicy_TLS13_1_2_PFS_PQ_2025_09" ->
        decode.success(SecurityPolicySecuritypolicyTls1312PfsPq202509)
      "SecurityPolicy_TLS13_1_2_PQ_2025_09" ->
        decode.success(SecurityPolicySecuritypolicyTls1312Pq202509)
      "SecurityPolicy_TLS13_1_3_2025_09" ->
        decode.success(SecurityPolicySecuritypolicyTls1313202509)
      "SecurityPolicy_TLS13_1_3_FIPS_2025_09" ->
        decode.success(SecurityPolicySecuritypolicyTls1313Fips202509)
      "SecurityPolicy_TLS13_2025_EDGE" ->
        decode.success(SecurityPolicySecuritypolicyTls132025Edge)
      "TLS_1_0" -> decode.success(SecurityPolicyTls10)
      "TLS_1_2" -> decode.success(SecurityPolicyTls12)
      _ ->
        decode.failure(
          SecurityPolicySecuritypolicyTls122018Edge,
          "unknown enum value",
        )
    }
  })
}

pub fn security_policy_from_wire(s: String) -> Result(SecurityPolicy, String) {
  case s {
    "SecurityPolicy_TLS12_2018_EDGE" ->
      Ok(SecurityPolicySecuritypolicyTls122018Edge)
    "SecurityPolicy_TLS12_PFS_2025_EDGE" ->
      Ok(SecurityPolicySecuritypolicyTls12Pfs2025Edge)
    "SecurityPolicy_TLS13_1_2_2021_06" ->
      Ok(SecurityPolicySecuritypolicyTls1312202106)
    "SecurityPolicy_TLS13_1_2_FIPS_PFS_PQ_2025_09" ->
      Ok(SecurityPolicySecuritypolicyTls1312FipsPfsPq202509)
    "SecurityPolicy_TLS13_1_2_FIPS_PQ_2025_09" ->
      Ok(SecurityPolicySecuritypolicyTls1312FipsPq202509)
    "SecurityPolicy_TLS13_1_2_PFS_PQ_2025_09" ->
      Ok(SecurityPolicySecuritypolicyTls1312PfsPq202509)
    "SecurityPolicy_TLS13_1_2_PQ_2025_09" ->
      Ok(SecurityPolicySecuritypolicyTls1312Pq202509)
    "SecurityPolicy_TLS13_1_3_2025_09" ->
      Ok(SecurityPolicySecuritypolicyTls1313202509)
    "SecurityPolicy_TLS13_1_3_FIPS_2025_09" ->
      Ok(SecurityPolicySecuritypolicyTls1313Fips202509)
    "SecurityPolicy_TLS13_2025_EDGE" ->
      Ok(SecurityPolicySecuritypolicyTls132025Edge)
    "TLS_1_0" -> Ok(SecurityPolicyTls10)
    "TLS_1_2" -> Ok(SecurityPolicyTls12)
    _ -> Ok(SecurityPolicySecuritypolicyTls122018Edge)
  }
}

pub type DomainName {
  DomainName(
    certificate_arn: option.Option(String),
    certificate_name: option.Option(String),
    certificate_upload_date: option.Option(json_timestamp.Timestamp),
    distribution_domain_name: option.Option(String),
    distribution_hosted_zone_id: option.Option(String),
    domain_name: option.Option(String),
    domain_name_arn: option.Option(String),
    domain_name_id: option.Option(String),
    domain_name_status: option.Option(DomainNameStatus),
    domain_name_status_message: option.Option(String),
    endpoint_access_mode: option.Option(EndpointAccessMode),
    endpoint_configuration: option.Option(EndpointConfiguration),
    management_policy: option.Option(String),
    mutual_tls_authentication: option.Option(MutualTlsAuthentication),
    ownership_verification_certificate_arn: option.Option(String),
    policy: option.Option(String),
    regional_certificate_arn: option.Option(String),
    regional_certificate_name: option.Option(String),
    regional_domain_name: option.Option(String),
    regional_hosted_zone_id: option.Option(String),
    routing_mode: option.Option(RoutingMode),
    security_policy: option.Option(SecurityPolicy),
    tags: option.Option(dict.Dict(String, String)),
  )
}

pub fn encode_domain_name_struct(input: DomainName) -> json.Json {
  let pairs = []
  let pairs = case input.certificate_arn {
    option.Some(v) -> [#("certificateArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.certificate_name {
    option.Some(v) -> [#("certificateName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.certificate_upload_date {
    option.Some(v) -> [
      #("certificateUploadDate", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.distribution_domain_name {
    option.Some(v) -> [#("distributionDomainName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.distribution_hosted_zone_id {
    option.Some(v) -> [#("distributionHostedZoneId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.domain_name {
    option.Some(v) -> [#("domainName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.domain_name_arn {
    option.Some(v) -> [#("domainNameArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.domain_name_id {
    option.Some(v) -> [#("domainNameId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.domain_name_status {
    option.Some(v) -> [
      #("domainNameStatus", encode_domain_name_status_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.domain_name_status_message {
    option.Some(v) -> [#("domainNameStatusMessage", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.endpoint_access_mode {
    option.Some(v) -> [
      #("endpointAccessMode", encode_endpoint_access_mode_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.endpoint_configuration {
    option.Some(v) -> [
      #("endpointConfiguration", encode_endpoint_configuration_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.management_policy {
    option.Some(v) -> [#("managementPolicy", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.mutual_tls_authentication {
    option.Some(v) -> [
      #("mutualTlsAuthentication", encode_mutual_tls_authentication_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.ownership_verification_certificate_arn {
    option.Some(v) -> [
      #("ownershipVerificationCertificateArn", 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.regional_certificate_arn {
    option.Some(v) -> [#("regionalCertificateArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.regional_certificate_name {
    option.Some(v) -> [#("regionalCertificateName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.regional_domain_name {
    option.Some(v) -> [#("regionalDomainName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.regional_hosted_zone_id {
    option.Some(v) -> [#("regionalHostedZoneId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.routing_mode {
    option.Some(v) -> [#("routingMode", encode_routing_mode_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.security_policy {
    option.Some(v) -> [
      #("securityPolicy", encode_security_policy_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.tags {
    option.Some(v) -> [
      #(
        "tags",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_domain_name_struct() -> decode.Decoder(DomainName) {
  use <- decode.recursive
  use certificate_arn <- decode.optional_field(
    "certificateArn",
    option.None,
    decode.optional(decode.string),
  )
  use certificate_name <- decode.optional_field(
    "certificateName",
    option.None,
    decode.optional(decode.string),
  )
  use certificate_upload_date <- decode.optional_field(
    "certificateUploadDate",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use distribution_domain_name <- decode.optional_field(
    "distributionDomainName",
    option.None,
    decode.optional(decode.string),
  )
  use distribution_hosted_zone_id <- decode.optional_field(
    "distributionHostedZoneId",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name <- decode.optional_field(
    "domainName",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name_arn <- decode.optional_field(
    "domainNameArn",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name_id <- decode.optional_field(
    "domainNameId",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name_status <- decode.optional_field(
    "domainNameStatus",
    option.None,
    decode.optional(decode_domain_name_status_enum()),
  )
  use domain_name_status_message <- decode.optional_field(
    "domainNameStatusMessage",
    option.None,
    decode.optional(decode.string),
  )
  use endpoint_access_mode <- decode.optional_field(
    "endpointAccessMode",
    option.None,
    decode.optional(decode_endpoint_access_mode_enum()),
  )
  use endpoint_configuration <- decode.optional_field(
    "endpointConfiguration",
    option.None,
    decode.optional(decode_endpoint_configuration_struct()),
  )
  use management_policy <- decode.optional_field(
    "managementPolicy",
    option.None,
    decode.optional(decode.string),
  )
  use mutual_tls_authentication <- decode.optional_field(
    "mutualTlsAuthentication",
    option.None,
    decode.optional(decode_mutual_tls_authentication_struct()),
  )
  use ownership_verification_certificate_arn <- decode.optional_field(
    "ownershipVerificationCertificateArn",
    option.None,
    decode.optional(decode.string),
  )
  use policy <- decode.optional_field(
    "policy",
    option.None,
    decode.optional(decode.string),
  )
  use regional_certificate_arn <- decode.optional_field(
    "regionalCertificateArn",
    option.None,
    decode.optional(decode.string),
  )
  use regional_certificate_name <- decode.optional_field(
    "regionalCertificateName",
    option.None,
    decode.optional(decode.string),
  )
  use regional_domain_name <- decode.optional_field(
    "regionalDomainName",
    option.None,
    decode.optional(decode.string),
  )
  use regional_hosted_zone_id <- decode.optional_field(
    "regionalHostedZoneId",
    option.None,
    decode.optional(decode.string),
  )
  use routing_mode <- decode.optional_field(
    "routingMode",
    option.None,
    decode.optional(decode_routing_mode_enum()),
  )
  use security_policy <- decode.optional_field(
    "securityPolicy",
    option.None,
    decode.optional(decode_security_policy_enum()),
  )
  use tags <- decode.optional_field(
    "tags",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  decode.success(DomainName(
    certificate_arn: certificate_arn,
    certificate_name: certificate_name,
    certificate_upload_date: certificate_upload_date,
    distribution_domain_name: distribution_domain_name,
    distribution_hosted_zone_id: distribution_hosted_zone_id,
    domain_name: domain_name,
    domain_name_arn: domain_name_arn,
    domain_name_id: domain_name_id,
    domain_name_status: domain_name_status,
    domain_name_status_message: domain_name_status_message,
    endpoint_access_mode: endpoint_access_mode,
    endpoint_configuration: endpoint_configuration,
    management_policy: management_policy,
    mutual_tls_authentication: mutual_tls_authentication,
    ownership_verification_certificate_arn: ownership_verification_certificate_arn,
    policy: policy,
    regional_certificate_arn: regional_certificate_arn,
    regional_certificate_name: regional_certificate_name,
    regional_domain_name: regional_domain_name,
    regional_hosted_zone_id: regional_hosted_zone_id,
    routing_mode: routing_mode,
    security_policy: security_policy,
    tags: tags,
  ))
}

pub fn decode_domain_name_struct_params() -> decode.Decoder(DomainName) {
  use <- decode.recursive
  use certificate_arn <- decode.optional_field(
    "certificateArn",
    option.None,
    decode.optional(decode.string),
  )
  use certificate_name <- decode.optional_field(
    "certificateName",
    option.None,
    decode.optional(decode.string),
  )
  use certificate_upload_date <- decode.optional_field(
    "certificateUploadDate",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use distribution_domain_name <- decode.optional_field(
    "distributionDomainName",
    option.None,
    decode.optional(decode.string),
  )
  use distribution_hosted_zone_id <- decode.optional_field(
    "distributionHostedZoneId",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name <- decode.optional_field(
    "domainName",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name_arn <- decode.optional_field(
    "domainNameArn",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name_id <- decode.optional_field(
    "domainNameId",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name_status <- decode.optional_field(
    "domainNameStatus",
    option.None,
    decode.optional(decode_domain_name_status_enum()),
  )
  use domain_name_status_message <- decode.optional_field(
    "domainNameStatusMessage",
    option.None,
    decode.optional(decode.string),
  )
  use endpoint_access_mode <- decode.optional_field(
    "endpointAccessMode",
    option.None,
    decode.optional(decode_endpoint_access_mode_enum()),
  )
  use endpoint_configuration <- decode.optional_field(
    "endpointConfiguration",
    option.None,
    decode.optional(decode_endpoint_configuration_struct_params()),
  )
  use management_policy <- decode.optional_field(
    "managementPolicy",
    option.None,
    decode.optional(decode.string),
  )
  use mutual_tls_authentication <- decode.optional_field(
    "mutualTlsAuthentication",
    option.None,
    decode.optional(decode_mutual_tls_authentication_struct_params()),
  )
  use ownership_verification_certificate_arn <- decode.optional_field(
    "ownershipVerificationCertificateArn",
    option.None,
    decode.optional(decode.string),
  )
  use policy <- decode.optional_field(
    "policy",
    option.None,
    decode.optional(decode.string),
  )
  use regional_certificate_arn <- decode.optional_field(
    "regionalCertificateArn",
    option.None,
    decode.optional(decode.string),
  )
  use regional_certificate_name <- decode.optional_field(
    "regionalCertificateName",
    option.None,
    decode.optional(decode.string),
  )
  use regional_domain_name <- decode.optional_field(
    "regionalDomainName",
    option.None,
    decode.optional(decode.string),
  )
  use regional_hosted_zone_id <- decode.optional_field(
    "regionalHostedZoneId",
    option.None,
    decode.optional(decode.string),
  )
  use routing_mode <- decode.optional_field(
    "routingMode",
    option.None,
    decode.optional(decode_routing_mode_enum()),
  )
  use security_policy <- decode.optional_field(
    "securityPolicy",
    option.None,
    decode.optional(decode_security_policy_enum()),
  )
  use tags <- decode.optional_field(
    "tags",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  decode.success(DomainName(
    certificate_arn: certificate_arn,
    certificate_name: certificate_name,
    certificate_upload_date: certificate_upload_date,
    distribution_domain_name: distribution_domain_name,
    distribution_hosted_zone_id: distribution_hosted_zone_id,
    domain_name: domain_name,
    domain_name_arn: domain_name_arn,
    domain_name_id: domain_name_id,
    domain_name_status: domain_name_status,
    domain_name_status_message: domain_name_status_message,
    endpoint_access_mode: endpoint_access_mode,
    endpoint_configuration: endpoint_configuration,
    management_policy: management_policy,
    mutual_tls_authentication: mutual_tls_authentication,
    ownership_verification_certificate_arn: ownership_verification_certificate_arn,
    policy: policy,
    regional_certificate_arn: regional_certificate_arn,
    regional_certificate_name: regional_certificate_name,
    regional_domain_name: regional_domain_name,
    regional_hosted_zone_id: regional_hosted_zone_id,
    routing_mode: routing_mode,
    security_policy: security_policy,
    tags: tags,
  ))
}

pub type DomainNameStatus {
  DomainNameStatusAvailable
  DomainNameStatusFailed
  DomainNameStatusPending
  DomainNameStatusPendingCertificateReimport
  DomainNameStatusPendingOwnershipVerification
  DomainNameStatusUpdating
}

pub fn encode_domain_name_status_enum(v: DomainNameStatus) -> json.Json {
  case v {
    DomainNameStatusAvailable -> json.string("AVAILABLE")
    DomainNameStatusFailed -> json.string("FAILED")
    DomainNameStatusPending -> json.string("PENDING")
    DomainNameStatusPendingCertificateReimport ->
      json.string("PENDING_CERTIFICATE_REIMPORT")
    DomainNameStatusPendingOwnershipVerification ->
      json.string("PENDING_OWNERSHIP_VERIFICATION")
    DomainNameStatusUpdating -> json.string("UPDATING")
  }
}

pub fn decode_domain_name_status_enum() -> decode.Decoder(DomainNameStatus) {
  decode.then(decode.string, fn(s) {
    case s {
      "AVAILABLE" -> decode.success(DomainNameStatusAvailable)
      "FAILED" -> decode.success(DomainNameStatusFailed)
      "PENDING" -> decode.success(DomainNameStatusPending)
      "PENDING_CERTIFICATE_REIMPORT" ->
        decode.success(DomainNameStatusPendingCertificateReimport)
      "PENDING_OWNERSHIP_VERIFICATION" ->
        decode.success(DomainNameStatusPendingOwnershipVerification)
      "UPDATING" -> decode.success(DomainNameStatusUpdating)
      _ -> decode.failure(DomainNameStatusAvailable, "unknown enum value")
    }
  })
}

pub fn domain_name_status_from_wire(
  s: String,
) -> Result(DomainNameStatus, String) {
  case s {
    "AVAILABLE" -> Ok(DomainNameStatusAvailable)
    "FAILED" -> Ok(DomainNameStatusFailed)
    "PENDING" -> Ok(DomainNameStatusPending)
    "PENDING_CERTIFICATE_REIMPORT" ->
      Ok(DomainNameStatusPendingCertificateReimport)
    "PENDING_OWNERSHIP_VERIFICATION" ->
      Ok(DomainNameStatusPendingOwnershipVerification)
    "UPDATING" -> Ok(DomainNameStatusUpdating)
    _ -> Ok(DomainNameStatusAvailable)
  }
}

pub type MutualTlsAuthentication {
  MutualTlsAuthentication(
    truststore_uri: option.Option(String),
    truststore_version: option.Option(String),
    truststore_warnings: option.Option(List(String)),
  )
}

pub fn encode_mutual_tls_authentication_struct(
  input: MutualTlsAuthentication,
) -> json.Json {
  let pairs = []
  let pairs = case input.truststore_uri {
    option.Some(v) -> [#("truststoreUri", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.truststore_version {
    option.Some(v) -> [#("truststoreVersion", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.truststore_warnings {
    option.Some(v) -> [
      #("truststoreWarnings", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_mutual_tls_authentication_struct() -> decode.Decoder(
  MutualTlsAuthentication,
) {
  use <- decode.recursive
  use truststore_uri <- decode.optional_field(
    "truststoreUri",
    option.None,
    decode.optional(decode.string),
  )
  use truststore_version <- decode.optional_field(
    "truststoreVersion",
    option.None,
    decode.optional(decode.string),
  )
  use truststore_warnings <- decode.optional_field(
    "truststoreWarnings",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  decode.success(MutualTlsAuthentication(
    truststore_uri: truststore_uri,
    truststore_version: truststore_version,
    truststore_warnings: truststore_warnings,
  ))
}

pub fn decode_mutual_tls_authentication_struct_params() -> decode.Decoder(
  MutualTlsAuthentication,
) {
  use <- decode.recursive
  use truststore_uri <- decode.optional_field(
    "truststoreUri",
    option.None,
    decode.optional(decode.string),
  )
  use truststore_version <- decode.optional_field(
    "truststoreVersion",
    option.None,
    decode.optional(decode.string),
  )
  use truststore_warnings <- decode.optional_field(
    "truststoreWarnings",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  decode.success(MutualTlsAuthentication(
    truststore_uri: truststore_uri,
    truststore_version: truststore_version,
    truststore_warnings: truststore_warnings,
  ))
}

pub type CreateDomainNameAccessAssociationRequest {
  CreateDomainNameAccessAssociationRequest(
    access_association_source: option.Option(String),
    access_association_source_type: option.Option(AccessAssociationSourceType),
    domain_name_arn: option.Option(String),
    tags: option.Option(dict.Dict(String, String)),
  )
}

pub fn encode_create_domain_name_access_association_request_struct(
  input: CreateDomainNameAccessAssociationRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.access_association_source {
    option.Some(v) -> [#("accessAssociationSource", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.access_association_source_type {
    option.Some(v) -> [
      #(
        "accessAssociationSourceType",
        encode_access_association_source_type_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.domain_name_arn {
    option.Some(v) -> [#("domainNameArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.tags {
    option.Some(v) -> [
      #(
        "tags",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_create_domain_name_access_association_request_struct() -> decode.Decoder(
  CreateDomainNameAccessAssociationRequest,
) {
  use <- decode.recursive
  use access_association_source <- decode.optional_field(
    "accessAssociationSource",
    option.None,
    decode.optional(decode.string),
  )
  use access_association_source_type <- decode.optional_field(
    "accessAssociationSourceType",
    option.None,
    decode.optional(decode_access_association_source_type_enum()),
  )
  use domain_name_arn <- decode.optional_field(
    "domainNameArn",
    option.None,
    decode.optional(decode.string),
  )
  use tags <- decode.optional_field(
    "tags",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  decode.success(CreateDomainNameAccessAssociationRequest(
    access_association_source: access_association_source,
    access_association_source_type: access_association_source_type,
    domain_name_arn: domain_name_arn,
    tags: tags,
  ))
}

pub fn decode_create_domain_name_access_association_request_struct_params() -> decode.Decoder(
  CreateDomainNameAccessAssociationRequest,
) {
  use <- decode.recursive
  use access_association_source <- decode.optional_field(
    "accessAssociationSource",
    option.None,
    decode.optional(decode.string),
  )
  use access_association_source_type <- decode.optional_field(
    "accessAssociationSourceType",
    option.None,
    decode.optional(decode_access_association_source_type_enum()),
  )
  use domain_name_arn <- decode.optional_field(
    "domainNameArn",
    option.None,
    decode.optional(decode.string),
  )
  use tags <- decode.optional_field(
    "tags",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  decode.success(CreateDomainNameAccessAssociationRequest(
    access_association_source: access_association_source,
    access_association_source_type: access_association_source_type,
    domain_name_arn: domain_name_arn,
    tags: tags,
  ))
}

pub type AccessAssociationSourceType {
  AccessAssociationSourceTypeVpce
}

pub fn encode_access_association_source_type_enum(
  v: AccessAssociationSourceType,
) -> json.Json {
  case v {
    AccessAssociationSourceTypeVpce -> json.string("VPCE")
  }
}

pub fn decode_access_association_source_type_enum() -> decode.Decoder(
  AccessAssociationSourceType,
) {
  decode.then(decode.string, fn(s) {
    case s {
      "VPCE" -> decode.success(AccessAssociationSourceTypeVpce)
      _ -> decode.failure(AccessAssociationSourceTypeVpce, "unknown enum value")
    }
  })
}

pub fn access_association_source_type_from_wire(
  s: String,
) -> Result(AccessAssociationSourceType, String) {
  case s {
    "VPCE" -> Ok(AccessAssociationSourceTypeVpce)
    _ -> Ok(AccessAssociationSourceTypeVpce)
  }
}

pub type DomainNameAccessAssociation {
  DomainNameAccessAssociation(
    access_association_source: option.Option(String),
    access_association_source_type: option.Option(AccessAssociationSourceType),
    domain_name_access_association_arn: option.Option(String),
    domain_name_arn: option.Option(String),
    tags: option.Option(dict.Dict(String, String)),
  )
}

pub fn encode_domain_name_access_association_struct(
  input: DomainNameAccessAssociation,
) -> json.Json {
  let pairs = []
  let pairs = case input.access_association_source {
    option.Some(v) -> [#("accessAssociationSource", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.access_association_source_type {
    option.Some(v) -> [
      #(
        "accessAssociationSourceType",
        encode_access_association_source_type_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.domain_name_access_association_arn {
    option.Some(v) -> [
      #("domainNameAccessAssociationArn", json.string(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.domain_name_arn {
    option.Some(v) -> [#("domainNameArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.tags {
    option.Some(v) -> [
      #(
        "tags",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_domain_name_access_association_struct() -> decode.Decoder(
  DomainNameAccessAssociation,
) {
  use <- decode.recursive
  use access_association_source <- decode.optional_field(
    "accessAssociationSource",
    option.None,
    decode.optional(decode.string),
  )
  use access_association_source_type <- decode.optional_field(
    "accessAssociationSourceType",
    option.None,
    decode.optional(decode_access_association_source_type_enum()),
  )
  use domain_name_access_association_arn <- decode.optional_field(
    "domainNameAccessAssociationArn",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name_arn <- decode.optional_field(
    "domainNameArn",
    option.None,
    decode.optional(decode.string),
  )
  use tags <- decode.optional_field(
    "tags",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  decode.success(DomainNameAccessAssociation(
    access_association_source: access_association_source,
    access_association_source_type: access_association_source_type,
    domain_name_access_association_arn: domain_name_access_association_arn,
    domain_name_arn: domain_name_arn,
    tags: tags,
  ))
}

pub fn decode_domain_name_access_association_struct_params() -> decode.Decoder(
  DomainNameAccessAssociation,
) {
  use <- decode.recursive
  use access_association_source <- decode.optional_field(
    "accessAssociationSource",
    option.None,
    decode.optional(decode.string),
  )
  use access_association_source_type <- decode.optional_field(
    "accessAssociationSourceType",
    option.None,
    decode.optional(decode_access_association_source_type_enum()),
  )
  use domain_name_access_association_arn <- decode.optional_field(
    "domainNameAccessAssociationArn",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name_arn <- decode.optional_field(
    "domainNameArn",
    option.None,
    decode.optional(decode.string),
  )
  use tags <- decode.optional_field(
    "tags",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  decode.success(DomainNameAccessAssociation(
    access_association_source: access_association_source,
    access_association_source_type: access_association_source_type,
    domain_name_access_association_arn: domain_name_access_association_arn,
    domain_name_arn: domain_name_arn,
    tags: tags,
  ))
}

pub type CreateModelRequest {
  CreateModelRequest(
    content_type: option.Option(String),
    description: option.Option(String),
    name: option.Option(String),
    rest_api_id: option.Option(String),
    schema: option.Option(String),
  )
}

pub fn encode_create_model_request_struct(
  input: CreateModelRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.content_type {
    option.Some(v) -> [#("contentType", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.description {
    option.Some(v) -> [#("description", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.name {
    option.Some(v) -> [#("name", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.schema {
    option.Some(v) -> [#("schema", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_create_model_request_struct() -> decode.Decoder(
  CreateModelRequest,
) {
  use <- decode.recursive
  use content_type <- decode.optional_field(
    "contentType",
    option.None,
    decode.optional(decode.string),
  )
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use name <- decode.optional_field(
    "name",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use schema <- decode.optional_field(
    "schema",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(CreateModelRequest(
    content_type: content_type,
    description: description,
    name: name,
    rest_api_id: rest_api_id,
    schema: schema,
  ))
}

pub fn decode_create_model_request_struct_params() -> decode.Decoder(
  CreateModelRequest,
) {
  use <- decode.recursive
  use content_type <- decode.optional_field(
    "contentType",
    option.None,
    decode.optional(decode.string),
  )
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use name <- decode.optional_field(
    "name",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use schema <- decode.optional_field(
    "schema",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(CreateModelRequest(
    content_type: content_type,
    description: description,
    name: name,
    rest_api_id: rest_api_id,
    schema: schema,
  ))
}

pub type Model {
  Model(
    content_type: option.Option(String),
    description: option.Option(String),
    id: option.Option(String),
    name: option.Option(String),
    schema: option.Option(String),
  )
}

pub fn encode_model_struct(input: Model) -> json.Json {
  let pairs = []
  let pairs = case input.content_type {
    option.Some(v) -> [#("contentType", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.description {
    option.Some(v) -> [#("description", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.id {
    option.Some(v) -> [#("id", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.name {
    option.Some(v) -> [#("name", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.schema {
    option.Some(v) -> [#("schema", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_model_struct() -> decode.Decoder(Model) {
  use <- decode.recursive
  use content_type <- decode.optional_field(
    "contentType",
    option.None,
    decode.optional(decode.string),
  )
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use id <- decode.optional_field(
    "id",
    option.None,
    decode.optional(decode.string),
  )
  use name <- decode.optional_field(
    "name",
    option.None,
    decode.optional(decode.string),
  )
  use schema <- decode.optional_field(
    "schema",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(Model(
    content_type: content_type,
    description: description,
    id: id,
    name: name,
    schema: schema,
  ))
}

pub fn decode_model_struct_params() -> decode.Decoder(Model) {
  use <- decode.recursive
  use content_type <- decode.optional_field(
    "contentType",
    option.None,
    decode.optional(decode.string),
  )
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use id <- decode.optional_field(
    "id",
    option.None,
    decode.optional(decode.string),
  )
  use name <- decode.optional_field(
    "name",
    option.None,
    decode.optional(decode.string),
  )
  use schema <- decode.optional_field(
    "schema",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(Model(
    content_type: content_type,
    description: description,
    id: id,
    name: name,
    schema: schema,
  ))
}

pub type CreateRequestValidatorRequest {
  CreateRequestValidatorRequest(
    name: option.Option(String),
    rest_api_id: option.Option(String),
    validate_request_body: option.Option(Bool),
    validate_request_parameters: option.Option(Bool),
  )
}

pub fn encode_create_request_validator_request_struct(
  input: CreateRequestValidatorRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.name {
    option.Some(v) -> [#("name", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.validate_request_body {
    option.Some(v) -> [#("validateRequestBody", json.bool(v)), ..pairs]
    option.None -> [#("validateRequestBody", json.bool(False)), ..pairs]
  }
  let pairs = case input.validate_request_parameters {
    option.Some(v) -> [#("validateRequestParameters", json.bool(v)), ..pairs]
    option.None -> [#("validateRequestParameters", json.bool(False)), ..pairs]
  }
  json.object(pairs)
}

pub fn decode_create_request_validator_request_struct() -> decode.Decoder(
  CreateRequestValidatorRequest,
) {
  use <- decode.recursive
  use name <- decode.optional_field(
    "name",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use validate_request_body <- decode.optional_field(
    "validateRequestBody",
    option.None,
    decode.optional(decode.bool),
  )
  use validate_request_parameters <- decode.optional_field(
    "validateRequestParameters",
    option.None,
    decode.optional(decode.bool),
  )
  decode.success(CreateRequestValidatorRequest(
    name: name,
    rest_api_id: rest_api_id,
    validate_request_body: validate_request_body,
    validate_request_parameters: validate_request_parameters,
  ))
}

pub fn decode_create_request_validator_request_struct_params() -> decode.Decoder(
  CreateRequestValidatorRequest,
) {
  use <- decode.recursive
  use name <- decode.optional_field(
    "name",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use validate_request_body <- decode.optional_field(
    "validateRequestBody",
    option.None,
    decode.optional(decode.bool),
  )
  use validate_request_parameters <- decode.optional_field(
    "validateRequestParameters",
    option.None,
    decode.optional(decode.bool),
  )
  decode.success(CreateRequestValidatorRequest(
    name: name,
    rest_api_id: rest_api_id,
    validate_request_body: validate_request_body,
    validate_request_parameters: validate_request_parameters,
  ))
}

pub type RequestValidator {
  RequestValidator(
    id: option.Option(String),
    name: option.Option(String),
    validate_request_body: option.Option(Bool),
    validate_request_parameters: option.Option(Bool),
  )
}

pub fn encode_request_validator_struct(input: RequestValidator) -> json.Json {
  let pairs = []
  let pairs = case input.id {
    option.Some(v) -> [#("id", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.name {
    option.Some(v) -> [#("name", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.validate_request_body {
    option.Some(v) -> [#("validateRequestBody", json.bool(v)), ..pairs]
    option.None -> [#("validateRequestBody", json.bool(False)), ..pairs]
  }
  let pairs = case input.validate_request_parameters {
    option.Some(v) -> [#("validateRequestParameters", json.bool(v)), ..pairs]
    option.None -> [#("validateRequestParameters", json.bool(False)), ..pairs]
  }
  json.object(pairs)
}

pub fn decode_request_validator_struct() -> decode.Decoder(RequestValidator) {
  use <- decode.recursive
  use id <- decode.optional_field(
    "id",
    option.None,
    decode.optional(decode.string),
  )
  use name <- decode.optional_field(
    "name",
    option.None,
    decode.optional(decode.string),
  )
  use validate_request_body <- decode.optional_field(
    "validateRequestBody",
    option.None,
    decode.optional(decode.bool),
  )
  use validate_request_parameters <- decode.optional_field(
    "validateRequestParameters",
    option.None,
    decode.optional(decode.bool),
  )
  decode.success(RequestValidator(
    id: id,
    name: name,
    validate_request_body: validate_request_body,
    validate_request_parameters: validate_request_parameters,
  ))
}

pub fn decode_request_validator_struct_params() -> decode.Decoder(
  RequestValidator,
) {
  use <- decode.recursive
  use id <- decode.optional_field(
    "id",
    option.None,
    decode.optional(decode.string),
  )
  use name <- decode.optional_field(
    "name",
    option.None,
    decode.optional(decode.string),
  )
  use validate_request_body <- decode.optional_field(
    "validateRequestBody",
    option.None,
    decode.optional(decode.bool),
  )
  use validate_request_parameters <- decode.optional_field(
    "validateRequestParameters",
    option.None,
    decode.optional(decode.bool),
  )
  decode.success(RequestValidator(
    id: id,
    name: name,
    validate_request_body: validate_request_body,
    validate_request_parameters: validate_request_parameters,
  ))
}

pub type CreateResourceRequest {
  CreateResourceRequest(
    parent_id: option.Option(String),
    path_part: option.Option(String),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_create_resource_request_struct(
  input: CreateResourceRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.parent_id {
    option.Some(v) -> [#("parentId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.path_part {
    option.Some(v) -> [#("pathPart", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_create_resource_request_struct() -> decode.Decoder(
  CreateResourceRequest,
) {
  use <- decode.recursive
  use parent_id <- decode.optional_field(
    "parentId",
    option.None,
    decode.optional(decode.string),
  )
  use path_part <- decode.optional_field(
    "pathPart",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(CreateResourceRequest(
    parent_id: parent_id,
    path_part: path_part,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_create_resource_request_struct_params() -> decode.Decoder(
  CreateResourceRequest,
) {
  use <- decode.recursive
  use parent_id <- decode.optional_field(
    "parentId",
    option.None,
    decode.optional(decode.string),
  )
  use path_part <- decode.optional_field(
    "pathPart",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(CreateResourceRequest(
    parent_id: parent_id,
    path_part: path_part,
    rest_api_id: rest_api_id,
  ))
}

pub type Resource {
  Resource(
    id: option.Option(String),
    parent_id: option.Option(String),
    path: option.Option(String),
    path_part: option.Option(String),
    resource_methods: option.Option(dict.Dict(String, Method)),
  )
}

pub fn encode_resource_struct(input: Resource) -> json.Json {
  let pairs = []
  let pairs = case input.id {
    option.Some(v) -> [#("id", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.parent_id {
    option.Some(v) -> [#("parentId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.path {
    option.Some(v) -> [#("path", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.path_part {
    option.Some(v) -> [#("pathPart", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.resource_methods {
    option.Some(v) -> [
      #(
        "resourceMethods",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, encode_method_struct(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_resource_struct() -> decode.Decoder(Resource) {
  use <- decode.recursive
  use id <- decode.optional_field(
    "id",
    option.None,
    decode.optional(decode.string),
  )
  use parent_id <- decode.optional_field(
    "parentId",
    option.None,
    decode.optional(decode.string),
  )
  use path <- decode.optional_field(
    "path",
    option.None,
    decode.optional(decode.string),
  )
  use path_part <- decode.optional_field(
    "pathPart",
    option.None,
    decode.optional(decode.string),
  )
  use resource_methods <- decode.optional_field(
    "resourceMethods",
    option.None,
    decode.optional(decode.dict(decode.string, decode_method_struct())),
  )
  decode.success(Resource(
    id: id,
    parent_id: parent_id,
    path: path,
    path_part: path_part,
    resource_methods: resource_methods,
  ))
}

pub fn decode_resource_struct_params() -> decode.Decoder(Resource) {
  use <- decode.recursive
  use id <- decode.optional_field(
    "id",
    option.None,
    decode.optional(decode.string),
  )
  use parent_id <- decode.optional_field(
    "parentId",
    option.None,
    decode.optional(decode.string),
  )
  use path <- decode.optional_field(
    "path",
    option.None,
    decode.optional(decode.string),
  )
  use path_part <- decode.optional_field(
    "pathPart",
    option.None,
    decode.optional(decode.string),
  )
  use resource_methods <- decode.optional_field(
    "resourceMethods",
    option.None,
    decode.optional(decode.dict(decode.string, decode_method_struct_params())),
  )
  decode.success(Resource(
    id: id,
    parent_id: parent_id,
    path: path,
    path_part: path_part,
    resource_methods: resource_methods,
  ))
}

pub type Method {
  Method(
    api_key_required: option.Option(Bool),
    authorization_scopes: option.Option(List(String)),
    authorization_type: option.Option(String),
    authorizer_id: option.Option(String),
    http_method: option.Option(String),
    method_integration: option.Option(Integration),
    method_responses: option.Option(dict.Dict(String, MethodResponse)),
    operation_name: option.Option(String),
    request_models: option.Option(dict.Dict(String, String)),
    request_parameters: option.Option(dict.Dict(String, Bool)),
    request_validator_id: option.Option(String),
  )
}

pub fn encode_method_struct(input: Method) -> json.Json {
  let pairs = []
  let pairs = case input.api_key_required {
    option.Some(v) -> [#("apiKeyRequired", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.authorization_scopes {
    option.Some(v) -> [
      #("authorizationScopes", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.authorization_type {
    option.Some(v) -> [#("authorizationType", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.authorizer_id {
    option.Some(v) -> [#("authorizerId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.http_method {
    option.Some(v) -> [#("httpMethod", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.method_integration {
    option.Some(v) -> [
      #("methodIntegration", encode_integration_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.method_responses {
    option.Some(v) -> [
      #(
        "methodResponses",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_method_response_struct(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.operation_name {
    option.Some(v) -> [#("operationName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.request_models {
    option.Some(v) -> [
      #(
        "requestModels",
        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.request_parameters {
    option.Some(v) -> [
      #(
        "requestParameters",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.bool(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.request_validator_id {
    option.Some(v) -> [#("requestValidatorId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_method_struct() -> decode.Decoder(Method) {
  use <- decode.recursive
  use api_key_required <- decode.optional_field(
    "apiKeyRequired",
    option.None,
    decode.optional(decode.bool),
  )
  use authorization_scopes <- decode.optional_field(
    "authorizationScopes",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  use authorization_type <- decode.optional_field(
    "authorizationType",
    option.None,
    decode.optional(decode.string),
  )
  use authorizer_id <- decode.optional_field(
    "authorizerId",
    option.None,
    decode.optional(decode.string),
  )
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use method_integration <- decode.optional_field(
    "methodIntegration",
    option.None,
    decode.optional(decode_integration_struct()),
  )
  use method_responses <- decode.optional_field(
    "methodResponses",
    option.None,
    decode.optional(decode.dict(decode.string, decode_method_response_struct())),
  )
  use operation_name <- decode.optional_field(
    "operationName",
    option.None,
    decode.optional(decode.string),
  )
  use request_models <- decode.optional_field(
    "requestModels",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use request_parameters <- decode.optional_field(
    "requestParameters",
    option.None,
    decode.optional(decode.dict(decode.string, decode.bool)),
  )
  use request_validator_id <- decode.optional_field(
    "requestValidatorId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(Method(
    api_key_required: api_key_required,
    authorization_scopes: authorization_scopes,
    authorization_type: authorization_type,
    authorizer_id: authorizer_id,
    http_method: http_method,
    method_integration: method_integration,
    method_responses: method_responses,
    operation_name: operation_name,
    request_models: request_models,
    request_parameters: request_parameters,
    request_validator_id: request_validator_id,
  ))
}

pub fn decode_method_struct_params() -> decode.Decoder(Method) {
  use <- decode.recursive
  use api_key_required <- decode.optional_field(
    "apiKeyRequired",
    option.None,
    decode.optional(decode.bool),
  )
  use authorization_scopes <- decode.optional_field(
    "authorizationScopes",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  use authorization_type <- decode.optional_field(
    "authorizationType",
    option.None,
    decode.optional(decode.string),
  )
  use authorizer_id <- decode.optional_field(
    "authorizerId",
    option.None,
    decode.optional(decode.string),
  )
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use method_integration <- decode.optional_field(
    "methodIntegration",
    option.None,
    decode.optional(decode_integration_struct_params()),
  )
  use method_responses <- decode.optional_field(
    "methodResponses",
    option.None,
    decode.optional(decode.dict(
      decode.string,
      decode_method_response_struct_params(),
    )),
  )
  use operation_name <- decode.optional_field(
    "operationName",
    option.None,
    decode.optional(decode.string),
  )
  use request_models <- decode.optional_field(
    "requestModels",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use request_parameters <- decode.optional_field(
    "requestParameters",
    option.None,
    decode.optional(decode.dict(decode.string, decode.bool)),
  )
  use request_validator_id <- decode.optional_field(
    "requestValidatorId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(Method(
    api_key_required: api_key_required,
    authorization_scopes: authorization_scopes,
    authorization_type: authorization_type,
    authorizer_id: authorizer_id,
    http_method: http_method,
    method_integration: method_integration,
    method_responses: method_responses,
    operation_name: operation_name,
    request_models: request_models,
    request_parameters: request_parameters,
    request_validator_id: request_validator_id,
  ))
}

pub type Integration {
  Integration(
    cache_key_parameters: option.Option(List(String)),
    cache_namespace: option.Option(String),
    connection_id: option.Option(String),
    connection_type: option.Option(ConnectionType),
    content_handling: option.Option(ContentHandlingStrategy),
    credentials: option.Option(String),
    http_method: option.Option(String),
    integration_responses: option.Option(dict.Dict(String, IntegrationResponse)),
    integration_target: option.Option(String),
    passthrough_behavior: option.Option(String),
    request_parameters: option.Option(dict.Dict(String, String)),
    request_templates: option.Option(dict.Dict(String, String)),
    response_transfer_mode: option.Option(ResponseTransferMode),
    timeout_in_millis: option.Option(Int),
    tls_config: option.Option(TlsConfig),
    type_: option.Option(IntegrationType),
    uri: option.Option(String),
  )
}

pub fn encode_integration_struct(input: Integration) -> json.Json {
  let pairs = []
  let pairs = case input.cache_key_parameters {
    option.Some(v) -> [
      #("cacheKeyParameters", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.cache_namespace {
    option.Some(v) -> [#("cacheNamespace", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.connection_id {
    option.Some(v) -> [#("connectionId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.connection_type {
    option.Some(v) -> [
      #("connectionType", encode_connection_type_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.content_handling {
    option.Some(v) -> [
      #("contentHandling", encode_content_handling_strategy_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.credentials {
    option.Some(v) -> [#("credentials", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.http_method {
    option.Some(v) -> [#("httpMethod", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.integration_responses {
    option.Some(v) -> [
      #(
        "integrationResponses",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_integration_response_struct(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.integration_target {
    option.Some(v) -> [#("integrationTarget", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.passthrough_behavior {
    option.Some(v) -> [#("passthroughBehavior", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.request_parameters {
    option.Some(v) -> [
      #(
        "requestParameters",
        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.request_templates {
    option.Some(v) -> [
      #(
        "requestTemplates",
        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.response_transfer_mode {
    option.Some(v) -> [
      #("responseTransferMode", encode_response_transfer_mode_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.timeout_in_millis {
    option.Some(v) -> [#("timeoutInMillis", json.int(v)), ..pairs]
    option.None -> [#("timeoutInMillis", json.int(0)), ..pairs]
  }
  let pairs = case input.tls_config {
    option.Some(v) -> [#("tlsConfig", encode_tls_config_struct(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.type_ {
    option.Some(v) -> [#("type", encode_integration_type_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.uri {
    option.Some(v) -> [#("uri", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_integration_struct() -> decode.Decoder(Integration) {
  use <- decode.recursive
  use cache_key_parameters <- decode.optional_field(
    "cacheKeyParameters",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  use cache_namespace <- decode.optional_field(
    "cacheNamespace",
    option.None,
    decode.optional(decode.string),
  )
  use connection_id <- decode.optional_field(
    "connectionId",
    option.None,
    decode.optional(decode.string),
  )
  use connection_type <- decode.optional_field(
    "connectionType",
    option.None,
    decode.optional(decode_connection_type_enum()),
  )
  use content_handling <- decode.optional_field(
    "contentHandling",
    option.None,
    decode.optional(decode_content_handling_strategy_enum()),
  )
  use credentials <- decode.optional_field(
    "credentials",
    option.None,
    decode.optional(decode.string),
  )
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use integration_responses <- decode.optional_field(
    "integrationResponses",
    option.None,
    decode.optional(decode.dict(
      decode.string,
      decode_integration_response_struct(),
    )),
  )
  use integration_target <- decode.optional_field(
    "integrationTarget",
    option.None,
    decode.optional(decode.string),
  )
  use passthrough_behavior <- decode.optional_field(
    "passthroughBehavior",
    option.None,
    decode.optional(decode.string),
  )
  use request_parameters <- decode.optional_field(
    "requestParameters",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use request_templates <- decode.optional_field(
    "requestTemplates",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use response_transfer_mode <- decode.optional_field(
    "responseTransferMode",
    option.None,
    decode.optional(decode_response_transfer_mode_enum()),
  )
  use timeout_in_millis <- decode.optional_field(
    "timeoutInMillis",
    option.None,
    decode.optional(decode.int),
  )
  use tls_config <- decode.optional_field(
    "tlsConfig",
    option.None,
    decode.optional(decode_tls_config_struct()),
  )
  use type_ <- decode.optional_field(
    "type",
    option.None,
    decode.optional(decode_integration_type_enum()),
  )
  use uri <- decode.optional_field(
    "uri",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(Integration(
    cache_key_parameters: cache_key_parameters,
    cache_namespace: cache_namespace,
    connection_id: connection_id,
    connection_type: connection_type,
    content_handling: content_handling,
    credentials: credentials,
    http_method: http_method,
    integration_responses: integration_responses,
    integration_target: integration_target,
    passthrough_behavior: passthrough_behavior,
    request_parameters: request_parameters,
    request_templates: request_templates,
    response_transfer_mode: response_transfer_mode,
    timeout_in_millis: timeout_in_millis,
    tls_config: tls_config,
    type_: type_,
    uri: uri,
  ))
}

pub fn decode_integration_struct_params() -> decode.Decoder(Integration) {
  use <- decode.recursive
  use cache_key_parameters <- decode.optional_field(
    "cacheKeyParameters",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  use cache_namespace <- decode.optional_field(
    "cacheNamespace",
    option.None,
    decode.optional(decode.string),
  )
  use connection_id <- decode.optional_field(
    "connectionId",
    option.None,
    decode.optional(decode.string),
  )
  use connection_type <- decode.optional_field(
    "connectionType",
    option.None,
    decode.optional(decode_connection_type_enum()),
  )
  use content_handling <- decode.optional_field(
    "contentHandling",
    option.None,
    decode.optional(decode_content_handling_strategy_enum()),
  )
  use credentials <- decode.optional_field(
    "credentials",
    option.None,
    decode.optional(decode.string),
  )
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use integration_responses <- decode.optional_field(
    "integrationResponses",
    option.None,
    decode.optional(decode.dict(
      decode.string,
      decode_integration_response_struct_params(),
    )),
  )
  use integration_target <- decode.optional_field(
    "integrationTarget",
    option.None,
    decode.optional(decode.string),
  )
  use passthrough_behavior <- decode.optional_field(
    "passthroughBehavior",
    option.None,
    decode.optional(decode.string),
  )
  use request_parameters <- decode.optional_field(
    "requestParameters",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use request_templates <- decode.optional_field(
    "requestTemplates",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use response_transfer_mode <- decode.optional_field(
    "responseTransferMode",
    option.None,
    decode.optional(decode_response_transfer_mode_enum()),
  )
  use timeout_in_millis <- decode.optional_field(
    "timeoutInMillis",
    option.None,
    decode.optional(decode.int),
  )
  use tls_config <- decode.optional_field(
    "tlsConfig",
    option.None,
    decode.optional(decode_tls_config_struct_params()),
  )
  use type_ <- decode.optional_field(
    "type",
    option.None,
    decode.optional(decode_integration_type_enum()),
  )
  use uri <- decode.optional_field(
    "uri",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(Integration(
    cache_key_parameters: cache_key_parameters,
    cache_namespace: cache_namespace,
    connection_id: connection_id,
    connection_type: connection_type,
    content_handling: content_handling,
    credentials: credentials,
    http_method: http_method,
    integration_responses: integration_responses,
    integration_target: integration_target,
    passthrough_behavior: passthrough_behavior,
    request_parameters: request_parameters,
    request_templates: request_templates,
    response_transfer_mode: response_transfer_mode,
    timeout_in_millis: timeout_in_millis,
    tls_config: tls_config,
    type_: type_,
    uri: uri,
  ))
}

pub type ConnectionType {
  ConnectionTypeInternet
  ConnectionTypeVpcLink
}

pub fn encode_connection_type_enum(v: ConnectionType) -> json.Json {
  case v {
    ConnectionTypeInternet -> json.string("INTERNET")
    ConnectionTypeVpcLink -> json.string("VPC_LINK")
  }
}

pub fn decode_connection_type_enum() -> decode.Decoder(ConnectionType) {
  decode.then(decode.string, fn(s) {
    case s {
      "INTERNET" -> decode.success(ConnectionTypeInternet)
      "VPC_LINK" -> decode.success(ConnectionTypeVpcLink)
      _ -> decode.failure(ConnectionTypeInternet, "unknown enum value")
    }
  })
}

pub fn connection_type_from_wire(s: String) -> Result(ConnectionType, String) {
  case s {
    "INTERNET" -> Ok(ConnectionTypeInternet)
    "VPC_LINK" -> Ok(ConnectionTypeVpcLink)
    _ -> Ok(ConnectionTypeInternet)
  }
}

pub type ContentHandlingStrategy {
  ContentHandlingStrategyConvertToBinary
  ContentHandlingStrategyConvertToText
}

pub fn encode_content_handling_strategy_enum(
  v: ContentHandlingStrategy,
) -> json.Json {
  case v {
    ContentHandlingStrategyConvertToBinary -> json.string("CONVERT_TO_BINARY")
    ContentHandlingStrategyConvertToText -> json.string("CONVERT_TO_TEXT")
  }
}

pub fn decode_content_handling_strategy_enum() -> decode.Decoder(
  ContentHandlingStrategy,
) {
  decode.then(decode.string, fn(s) {
    case s {
      "CONVERT_TO_BINARY" ->
        decode.success(ContentHandlingStrategyConvertToBinary)
      "CONVERT_TO_TEXT" -> decode.success(ContentHandlingStrategyConvertToText)
      _ ->
        decode.failure(
          ContentHandlingStrategyConvertToBinary,
          "unknown enum value",
        )
    }
  })
}

pub fn content_handling_strategy_from_wire(
  s: String,
) -> Result(ContentHandlingStrategy, String) {
  case s {
    "CONVERT_TO_BINARY" -> Ok(ContentHandlingStrategyConvertToBinary)
    "CONVERT_TO_TEXT" -> Ok(ContentHandlingStrategyConvertToText)
    _ -> Ok(ContentHandlingStrategyConvertToBinary)
  }
}

pub type IntegrationResponse {
  IntegrationResponse(
    content_handling: option.Option(ContentHandlingStrategy),
    response_parameters: option.Option(dict.Dict(String, String)),
    response_templates: option.Option(dict.Dict(String, String)),
    selection_pattern: option.Option(String),
    status_code: option.Option(String),
  )
}

pub fn encode_integration_response_struct(
  input: IntegrationResponse,
) -> json.Json {
  let pairs = []
  let pairs = case input.content_handling {
    option.Some(v) -> [
      #("contentHandling", encode_content_handling_strategy_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.response_parameters {
    option.Some(v) -> [
      #(
        "responseParameters",
        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.response_templates {
    option.Some(v) -> [
      #(
        "responseTemplates",
        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.selection_pattern {
    option.Some(v) -> [#("selectionPattern", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.status_code {
    option.Some(v) -> [#("statusCode", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_integration_response_struct() -> decode.Decoder(
  IntegrationResponse,
) {
  use <- decode.recursive
  use content_handling <- decode.optional_field(
    "contentHandling",
    option.None,
    decode.optional(decode_content_handling_strategy_enum()),
  )
  use response_parameters <- decode.optional_field(
    "responseParameters",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use response_templates <- decode.optional_field(
    "responseTemplates",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use selection_pattern <- decode.optional_field(
    "selectionPattern",
    option.None,
    decode.optional(decode.string),
  )
  use status_code <- decode.optional_field(
    "statusCode",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(IntegrationResponse(
    content_handling: content_handling,
    response_parameters: response_parameters,
    response_templates: response_templates,
    selection_pattern: selection_pattern,
    status_code: status_code,
  ))
}

pub fn decode_integration_response_struct_params() -> decode.Decoder(
  IntegrationResponse,
) {
  use <- decode.recursive
  use content_handling <- decode.optional_field(
    "contentHandling",
    option.None,
    decode.optional(decode_content_handling_strategy_enum()),
  )
  use response_parameters <- decode.optional_field(
    "responseParameters",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use response_templates <- decode.optional_field(
    "responseTemplates",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use selection_pattern <- decode.optional_field(
    "selectionPattern",
    option.None,
    decode.optional(decode.string),
  )
  use status_code <- decode.optional_field(
    "statusCode",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(IntegrationResponse(
    content_handling: content_handling,
    response_parameters: response_parameters,
    response_templates: response_templates,
    selection_pattern: selection_pattern,
    status_code: status_code,
  ))
}

pub type ResponseTransferMode {
  ResponseTransferModeBuffered
  ResponseTransferModeStream
}

pub fn encode_response_transfer_mode_enum(
  v: ResponseTransferMode,
) -> json.Json {
  case v {
    ResponseTransferModeBuffered -> json.string("BUFFERED")
    ResponseTransferModeStream -> json.string("STREAM")
  }
}

pub fn decode_response_transfer_mode_enum() -> decode.Decoder(
  ResponseTransferMode,
) {
  decode.then(decode.string, fn(s) {
    case s {
      "BUFFERED" -> decode.success(ResponseTransferModeBuffered)
      "STREAM" -> decode.success(ResponseTransferModeStream)
      _ -> decode.failure(ResponseTransferModeBuffered, "unknown enum value")
    }
  })
}

pub fn response_transfer_mode_from_wire(
  s: String,
) -> Result(ResponseTransferMode, String) {
  case s {
    "BUFFERED" -> Ok(ResponseTransferModeBuffered)
    "STREAM" -> Ok(ResponseTransferModeStream)
    _ -> Ok(ResponseTransferModeBuffered)
  }
}

pub type TlsConfig {
  TlsConfig(insecure_skip_verification: option.Option(Bool))
}

pub fn encode_tls_config_struct(input: TlsConfig) -> json.Json {
  let pairs = []
  let pairs = case input.insecure_skip_verification {
    option.Some(v) -> [#("insecureSkipVerification", json.bool(v)), ..pairs]
    option.None -> [#("insecureSkipVerification", json.bool(False)), ..pairs]
  }
  json.object(pairs)
}

pub fn decode_tls_config_struct() -> decode.Decoder(TlsConfig) {
  use <- decode.recursive
  use insecure_skip_verification <- decode.optional_field(
    "insecureSkipVerification",
    option.None,
    decode.optional(decode.bool),
  )
  decode.success(TlsConfig(
    insecure_skip_verification: insecure_skip_verification,
  ))
}

pub fn decode_tls_config_struct_params() -> decode.Decoder(TlsConfig) {
  use <- decode.recursive
  use insecure_skip_verification <- decode.optional_field(
    "insecureSkipVerification",
    option.None,
    decode.optional(decode.bool),
  )
  decode.success(TlsConfig(
    insecure_skip_verification: insecure_skip_verification,
  ))
}

pub type IntegrationType {
  IntegrationTypeAws
  IntegrationTypeAwsProxy
  IntegrationTypeHttp
  IntegrationTypeHttpProxy
  IntegrationTypeMock
}

pub fn encode_integration_type_enum(v: IntegrationType) -> json.Json {
  case v {
    IntegrationTypeAws -> json.string("AWS")
    IntegrationTypeAwsProxy -> json.string("AWS_PROXY")
    IntegrationTypeHttp -> json.string("HTTP")
    IntegrationTypeHttpProxy -> json.string("HTTP_PROXY")
    IntegrationTypeMock -> json.string("MOCK")
  }
}

pub fn decode_integration_type_enum() -> decode.Decoder(IntegrationType) {
  decode.then(decode.string, fn(s) {
    case s {
      "AWS" -> decode.success(IntegrationTypeAws)
      "AWS_PROXY" -> decode.success(IntegrationTypeAwsProxy)
      "HTTP" -> decode.success(IntegrationTypeHttp)
      "HTTP_PROXY" -> decode.success(IntegrationTypeHttpProxy)
      "MOCK" -> decode.success(IntegrationTypeMock)
      _ -> decode.failure(IntegrationTypeAws, "unknown enum value")
    }
  })
}

pub fn integration_type_from_wire(
  s: String,
) -> Result(IntegrationType, String) {
  case s {
    "AWS" -> Ok(IntegrationTypeAws)
    "AWS_PROXY" -> Ok(IntegrationTypeAwsProxy)
    "HTTP" -> Ok(IntegrationTypeHttp)
    "HTTP_PROXY" -> Ok(IntegrationTypeHttpProxy)
    "MOCK" -> Ok(IntegrationTypeMock)
    _ -> Ok(IntegrationTypeAws)
  }
}

pub type MethodResponse {
  MethodResponse(
    response_models: option.Option(dict.Dict(String, String)),
    response_parameters: option.Option(dict.Dict(String, Bool)),
    status_code: option.Option(String),
  )
}

pub fn encode_method_response_struct(input: MethodResponse) -> json.Json {
  let pairs = []
  let pairs = case input.response_models {
    option.Some(v) -> [
      #(
        "responseModels",
        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.response_parameters {
    option.Some(v) -> [
      #(
        "responseParameters",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.bool(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.status_code {
    option.Some(v) -> [#("statusCode", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_method_response_struct() -> decode.Decoder(MethodResponse) {
  use <- decode.recursive
  use response_models <- decode.optional_field(
    "responseModels",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use response_parameters <- decode.optional_field(
    "responseParameters",
    option.None,
    decode.optional(decode.dict(decode.string, decode.bool)),
  )
  use status_code <- decode.optional_field(
    "statusCode",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(MethodResponse(
    response_models: response_models,
    response_parameters: response_parameters,
    status_code: status_code,
  ))
}

pub fn decode_method_response_struct_params() -> decode.Decoder(MethodResponse) {
  use <- decode.recursive
  use response_models <- decode.optional_field(
    "responseModels",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use response_parameters <- decode.optional_field(
    "responseParameters",
    option.None,
    decode.optional(decode.dict(decode.string, decode.bool)),
  )
  use status_code <- decode.optional_field(
    "statusCode",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(MethodResponse(
    response_models: response_models,
    response_parameters: response_parameters,
    status_code: status_code,
  ))
}

pub type CreateRestApiRequest {
  CreateRestApiRequest(
    api_key_source: option.Option(ApiKeySourceType),
    binary_media_types: option.Option(List(String)),
    clone_from: option.Option(String),
    description: option.Option(String),
    disable_execute_api_endpoint: option.Option(Bool),
    endpoint_access_mode: option.Option(EndpointAccessMode),
    endpoint_configuration: option.Option(EndpointConfiguration),
    minimum_compression_size: option.Option(Int),
    name: option.Option(String),
    policy: option.Option(String),
    security_policy: option.Option(SecurityPolicy),
    tags: option.Option(dict.Dict(String, String)),
    version: option.Option(String),
  )
}

pub fn encode_create_rest_api_request_struct(
  input: CreateRestApiRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.api_key_source {
    option.Some(v) -> [
      #("apiKeySource", encode_api_key_source_type_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.binary_media_types {
    option.Some(v) -> [
      #("binaryMediaTypes", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.clone_from {
    option.Some(v) -> [#("cloneFrom", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.description {
    option.Some(v) -> [#("description", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.disable_execute_api_endpoint {
    option.Some(v) -> [#("disableExecuteApiEndpoint", json.bool(v)), ..pairs]
    option.None -> [#("disableExecuteApiEndpoint", json.bool(False)), ..pairs]
  }
  let pairs = case input.endpoint_access_mode {
    option.Some(v) -> [
      #("endpointAccessMode", encode_endpoint_access_mode_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.endpoint_configuration {
    option.Some(v) -> [
      #("endpointConfiguration", encode_endpoint_configuration_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.minimum_compression_size {
    option.Some(v) -> [#("minimumCompressionSize", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.name {
    option.Some(v) -> [#("name", 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.security_policy {
    option.Some(v) -> [
      #("securityPolicy", encode_security_policy_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.tags {
    option.Some(v) -> [
      #(
        "tags",
        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.version {
    option.Some(v) -> [#("version", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_create_rest_api_request_struct() -> decode.Decoder(
  CreateRestApiRequest,
) {
  use <- decode.recursive
  use api_key_source <- decode.optional_field(
    "apiKeySource",
    option.None,
    decode.optional(decode_api_key_source_type_enum()),
  )
  use binary_media_types <- decode.optional_field(
    "binaryMediaTypes",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  use clone_from <- decode.optional_field(
    "cloneFrom",
    option.None,
    decode.optional(decode.string),
  )
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use disable_execute_api_endpoint <- decode.optional_field(
    "disableExecuteApiEndpoint",
    option.None,
    decode.optional(decode.bool),
  )
  use endpoint_access_mode <- decode.optional_field(
    "endpointAccessMode",
    option.None,
    decode.optional(decode_endpoint_access_mode_enum()),
  )
  use endpoint_configuration <- decode.optional_field(
    "endpointConfiguration",
    option.None,
    decode.optional(decode_endpoint_configuration_struct()),
  )
  use minimum_compression_size <- decode.optional_field(
    "minimumCompressionSize",
    option.None,
    decode.optional(decode.int),
  )
  use name <- decode.optional_field(
    "name",
    option.None,
    decode.optional(decode.string),
  )
  use policy <- decode.optional_field(
    "policy",
    option.None,
    decode.optional(decode.string),
  )
  use security_policy <- decode.optional_field(
    "securityPolicy",
    option.None,
    decode.optional(decode_security_policy_enum()),
  )
  use tags <- decode.optional_field(
    "tags",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use version <- decode.optional_field(
    "version",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(CreateRestApiRequest(
    api_key_source: api_key_source,
    binary_media_types: binary_media_types,
    clone_from: clone_from,
    description: description,
    disable_execute_api_endpoint: disable_execute_api_endpoint,
    endpoint_access_mode: endpoint_access_mode,
    endpoint_configuration: endpoint_configuration,
    minimum_compression_size: minimum_compression_size,
    name: name,
    policy: policy,
    security_policy: security_policy,
    tags: tags,
    version: version,
  ))
}

pub fn decode_create_rest_api_request_struct_params() -> decode.Decoder(
  CreateRestApiRequest,
) {
  use <- decode.recursive
  use api_key_source <- decode.optional_field(
    "apiKeySource",
    option.None,
    decode.optional(decode_api_key_source_type_enum()),
  )
  use binary_media_types <- decode.optional_field(
    "binaryMediaTypes",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  use clone_from <- decode.optional_field(
    "cloneFrom",
    option.None,
    decode.optional(decode.string),
  )
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use disable_execute_api_endpoint <- decode.optional_field(
    "disableExecuteApiEndpoint",
    option.None,
    decode.optional(decode.bool),
  )
  use endpoint_access_mode <- decode.optional_field(
    "endpointAccessMode",
    option.None,
    decode.optional(decode_endpoint_access_mode_enum()),
  )
  use endpoint_configuration <- decode.optional_field(
    "endpointConfiguration",
    option.None,
    decode.optional(decode_endpoint_configuration_struct_params()),
  )
  use minimum_compression_size <- decode.optional_field(
    "minimumCompressionSize",
    option.None,
    decode.optional(decode.int),
  )
  use name <- decode.optional_field(
    "name",
    option.None,
    decode.optional(decode.string),
  )
  use policy <- decode.optional_field(
    "policy",
    option.None,
    decode.optional(decode.string),
  )
  use security_policy <- decode.optional_field(
    "securityPolicy",
    option.None,
    decode.optional(decode_security_policy_enum()),
  )
  use tags <- decode.optional_field(
    "tags",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use version <- decode.optional_field(
    "version",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(CreateRestApiRequest(
    api_key_source: api_key_source,
    binary_media_types: binary_media_types,
    clone_from: clone_from,
    description: description,
    disable_execute_api_endpoint: disable_execute_api_endpoint,
    endpoint_access_mode: endpoint_access_mode,
    endpoint_configuration: endpoint_configuration,
    minimum_compression_size: minimum_compression_size,
    name: name,
    policy: policy,
    security_policy: security_policy,
    tags: tags,
    version: version,
  ))
}

pub type ApiKeySourceType {
  ApiKeySourceTypeAuthorizer
  ApiKeySourceTypeHeader
}

pub fn encode_api_key_source_type_enum(v: ApiKeySourceType) -> json.Json {
  case v {
    ApiKeySourceTypeAuthorizer -> json.string("AUTHORIZER")
    ApiKeySourceTypeHeader -> json.string("HEADER")
  }
}

pub fn decode_api_key_source_type_enum() -> decode.Decoder(ApiKeySourceType) {
  decode.then(decode.string, fn(s) {
    case s {
      "AUTHORIZER" -> decode.success(ApiKeySourceTypeAuthorizer)
      "HEADER" -> decode.success(ApiKeySourceTypeHeader)
      _ -> decode.failure(ApiKeySourceTypeAuthorizer, "unknown enum value")
    }
  })
}

pub fn api_key_source_type_from_wire(
  s: String,
) -> Result(ApiKeySourceType, String) {
  case s {
    "AUTHORIZER" -> Ok(ApiKeySourceTypeAuthorizer)
    "HEADER" -> Ok(ApiKeySourceTypeHeader)
    _ -> Ok(ApiKeySourceTypeAuthorizer)
  }
}

pub type RestApi {
  RestApi(
    api_key_source: option.Option(ApiKeySourceType),
    api_status: option.Option(ApiStatus),
    api_status_message: option.Option(String),
    binary_media_types: option.Option(List(String)),
    created_date: option.Option(json_timestamp.Timestamp),
    description: option.Option(String),
    disable_execute_api_endpoint: option.Option(Bool),
    endpoint_access_mode: option.Option(EndpointAccessMode),
    endpoint_configuration: option.Option(EndpointConfiguration),
    id: option.Option(String),
    minimum_compression_size: option.Option(Int),
    name: option.Option(String),
    policy: option.Option(String),
    root_resource_id: option.Option(String),
    security_policy: option.Option(SecurityPolicy),
    tags: option.Option(dict.Dict(String, String)),
    version: option.Option(String),
    warnings: option.Option(List(String)),
  )
}

pub fn encode_rest_api_struct(input: RestApi) -> json.Json {
  let pairs = []
  let pairs = case input.api_key_source {
    option.Some(v) -> [
      #("apiKeySource", encode_api_key_source_type_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.api_status {
    option.Some(v) -> [#("apiStatus", encode_api_status_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.api_status_message {
    option.Some(v) -> [#("apiStatusMessage", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.binary_media_types {
    option.Some(v) -> [
      #("binaryMediaTypes", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.created_date {
    option.Some(v) -> [
      #("createdDate", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.description {
    option.Some(v) -> [#("description", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.disable_execute_api_endpoint {
    option.Some(v) -> [#("disableExecuteApiEndpoint", json.bool(v)), ..pairs]
    option.None -> [#("disableExecuteApiEndpoint", json.bool(False)), ..pairs]
  }
  let pairs = case input.endpoint_access_mode {
    option.Some(v) -> [
      #("endpointAccessMode", encode_endpoint_access_mode_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.endpoint_configuration {
    option.Some(v) -> [
      #("endpointConfiguration", encode_endpoint_configuration_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.id {
    option.Some(v) -> [#("id", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.minimum_compression_size {
    option.Some(v) -> [#("minimumCompressionSize", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.name {
    option.Some(v) -> [#("name", 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.root_resource_id {
    option.Some(v) -> [#("rootResourceId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.security_policy {
    option.Some(v) -> [
      #("securityPolicy", encode_security_policy_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.tags {
    option.Some(v) -> [
      #(
        "tags",
        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.version {
    option.Some(v) -> [#("version", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.warnings {
    option.Some(v) -> [
      #("warnings", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_rest_api_struct() -> decode.Decoder(RestApi) {
  use <- decode.recursive
  use api_key_source <- decode.optional_field(
    "apiKeySource",
    option.None,
    decode.optional(decode_api_key_source_type_enum()),
  )
  use api_status <- decode.optional_field(
    "apiStatus",
    option.None,
    decode.optional(decode_api_status_enum()),
  )
  use api_status_message <- decode.optional_field(
    "apiStatusMessage",
    option.None,
    decode.optional(decode.string),
  )
  use binary_media_types <- decode.optional_field(
    "binaryMediaTypes",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  use created_date <- decode.optional_field(
    "createdDate",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use disable_execute_api_endpoint <- decode.optional_field(
    "disableExecuteApiEndpoint",
    option.None,
    decode.optional(decode.bool),
  )
  use endpoint_access_mode <- decode.optional_field(
    "endpointAccessMode",
    option.None,
    decode.optional(decode_endpoint_access_mode_enum()),
  )
  use endpoint_configuration <- decode.optional_field(
    "endpointConfiguration",
    option.None,
    decode.optional(decode_endpoint_configuration_struct()),
  )
  use id <- decode.optional_field(
    "id",
    option.None,
    decode.optional(decode.string),
  )
  use minimum_compression_size <- decode.optional_field(
    "minimumCompressionSize",
    option.None,
    decode.optional(decode.int),
  )
  use name <- decode.optional_field(
    "name",
    option.None,
    decode.optional(decode.string),
  )
  use policy <- decode.optional_field(
    "policy",
    option.None,
    decode.optional(decode.string),
  )
  use root_resource_id <- decode.optional_field(
    "rootResourceId",
    option.None,
    decode.optional(decode.string),
  )
  use security_policy <- decode.optional_field(
    "securityPolicy",
    option.None,
    decode.optional(decode_security_policy_enum()),
  )
  use tags <- decode.optional_field(
    "tags",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use version <- decode.optional_field(
    "version",
    option.None,
    decode.optional(decode.string),
  )
  use warnings <- decode.optional_field(
    "warnings",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  decode.success(RestApi(
    api_key_source: api_key_source,
    api_status: api_status,
    api_status_message: api_status_message,
    binary_media_types: binary_media_types,
    created_date: created_date,
    description: description,
    disable_execute_api_endpoint: disable_execute_api_endpoint,
    endpoint_access_mode: endpoint_access_mode,
    endpoint_configuration: endpoint_configuration,
    id: id,
    minimum_compression_size: minimum_compression_size,
    name: name,
    policy: policy,
    root_resource_id: root_resource_id,
    security_policy: security_policy,
    tags: tags,
    version: version,
    warnings: warnings,
  ))
}

pub fn decode_rest_api_struct_params() -> decode.Decoder(RestApi) {
  use <- decode.recursive
  use api_key_source <- decode.optional_field(
    "apiKeySource",
    option.None,
    decode.optional(decode_api_key_source_type_enum()),
  )
  use api_status <- decode.optional_field(
    "apiStatus",
    option.None,
    decode.optional(decode_api_status_enum()),
  )
  use api_status_message <- decode.optional_field(
    "apiStatusMessage",
    option.None,
    decode.optional(decode.string),
  )
  use binary_media_types <- decode.optional_field(
    "binaryMediaTypes",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  use created_date <- decode.optional_field(
    "createdDate",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use disable_execute_api_endpoint <- decode.optional_field(
    "disableExecuteApiEndpoint",
    option.None,
    decode.optional(decode.bool),
  )
  use endpoint_access_mode <- decode.optional_field(
    "endpointAccessMode",
    option.None,
    decode.optional(decode_endpoint_access_mode_enum()),
  )
  use endpoint_configuration <- decode.optional_field(
    "endpointConfiguration",
    option.None,
    decode.optional(decode_endpoint_configuration_struct_params()),
  )
  use id <- decode.optional_field(
    "id",
    option.None,
    decode.optional(decode.string),
  )
  use minimum_compression_size <- decode.optional_field(
    "minimumCompressionSize",
    option.None,
    decode.optional(decode.int),
  )
  use name <- decode.optional_field(
    "name",
    option.None,
    decode.optional(decode.string),
  )
  use policy <- decode.optional_field(
    "policy",
    option.None,
    decode.optional(decode.string),
  )
  use root_resource_id <- decode.optional_field(
    "rootResourceId",
    option.None,
    decode.optional(decode.string),
  )
  use security_policy <- decode.optional_field(
    "securityPolicy",
    option.None,
    decode.optional(decode_security_policy_enum()),
  )
  use tags <- decode.optional_field(
    "tags",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use version <- decode.optional_field(
    "version",
    option.None,
    decode.optional(decode.string),
  )
  use warnings <- decode.optional_field(
    "warnings",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  decode.success(RestApi(
    api_key_source: api_key_source,
    api_status: api_status,
    api_status_message: api_status_message,
    binary_media_types: binary_media_types,
    created_date: created_date,
    description: description,
    disable_execute_api_endpoint: disable_execute_api_endpoint,
    endpoint_access_mode: endpoint_access_mode,
    endpoint_configuration: endpoint_configuration,
    id: id,
    minimum_compression_size: minimum_compression_size,
    name: name,
    policy: policy,
    root_resource_id: root_resource_id,
    security_policy: security_policy,
    tags: tags,
    version: version,
    warnings: warnings,
  ))
}

pub type ApiStatus {
  ApiStatusAvailable
  ApiStatusFailed
  ApiStatusPending
  ApiStatusUpdating
}

pub fn encode_api_status_enum(v: ApiStatus) -> json.Json {
  case v {
    ApiStatusAvailable -> json.string("AVAILABLE")
    ApiStatusFailed -> json.string("FAILED")
    ApiStatusPending -> json.string("PENDING")
    ApiStatusUpdating -> json.string("UPDATING")
  }
}

pub fn decode_api_status_enum() -> decode.Decoder(ApiStatus) {
  decode.then(decode.string, fn(s) {
    case s {
      "AVAILABLE" -> decode.success(ApiStatusAvailable)
      "FAILED" -> decode.success(ApiStatusFailed)
      "PENDING" -> decode.success(ApiStatusPending)
      "UPDATING" -> decode.success(ApiStatusUpdating)
      _ -> decode.failure(ApiStatusAvailable, "unknown enum value")
    }
  })
}

pub fn api_status_from_wire(s: String) -> Result(ApiStatus, String) {
  case s {
    "AVAILABLE" -> Ok(ApiStatusAvailable)
    "FAILED" -> Ok(ApiStatusFailed)
    "PENDING" -> Ok(ApiStatusPending)
    "UPDATING" -> Ok(ApiStatusUpdating)
    _ -> Ok(ApiStatusAvailable)
  }
}

pub type CreateStageRequest {
  CreateStageRequest(
    cache_cluster_enabled: option.Option(Bool),
    cache_cluster_size: option.Option(CacheClusterSize),
    canary_settings: option.Option(CanarySettings),
    deployment_id: option.Option(String),
    description: option.Option(String),
    documentation_version: option.Option(String),
    rest_api_id: option.Option(String),
    stage_name: option.Option(String),
    tags: option.Option(dict.Dict(String, String)),
    tracing_enabled: option.Option(Bool),
    variables: option.Option(dict.Dict(String, String)),
  )
}

pub fn encode_create_stage_request_struct(
  input: CreateStageRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.cache_cluster_enabled {
    option.Some(v) -> [#("cacheClusterEnabled", json.bool(v)), ..pairs]
    option.None -> [#("cacheClusterEnabled", json.bool(False)), ..pairs]
  }
  let pairs = case input.cache_cluster_size {
    option.Some(v) -> [
      #("cacheClusterSize", encode_cache_cluster_size_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.canary_settings {
    option.Some(v) -> [
      #("canarySettings", encode_canary_settings_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.deployment_id {
    option.Some(v) -> [#("deploymentId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.description {
    option.Some(v) -> [#("description", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.documentation_version {
    option.Some(v) -> [#("documentationVersion", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.stage_name {
    option.Some(v) -> [#("stageName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.tags {
    option.Some(v) -> [
      #(
        "tags",
        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.tracing_enabled {
    option.Some(v) -> [#("tracingEnabled", json.bool(v)), ..pairs]
    option.None -> [#("tracingEnabled", json.bool(False)), ..pairs]
  }
  let pairs = case input.variables {
    option.Some(v) -> [
      #(
        "variables",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_create_stage_request_struct() -> decode.Decoder(
  CreateStageRequest,
) {
  use <- decode.recursive
  use cache_cluster_enabled <- decode.optional_field(
    "cacheClusterEnabled",
    option.None,
    decode.optional(decode.bool),
  )
  use cache_cluster_size <- decode.optional_field(
    "cacheClusterSize",
    option.None,
    decode.optional(decode_cache_cluster_size_enum()),
  )
  use canary_settings <- decode.optional_field(
    "canarySettings",
    option.None,
    decode.optional(decode_canary_settings_struct()),
  )
  use deployment_id <- decode.optional_field(
    "deploymentId",
    option.None,
    decode.optional(decode.string),
  )
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use documentation_version <- decode.optional_field(
    "documentationVersion",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use stage_name <- decode.optional_field(
    "stageName",
    option.None,
    decode.optional(decode.string),
  )
  use tags <- decode.optional_field(
    "tags",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use tracing_enabled <- decode.optional_field(
    "tracingEnabled",
    option.None,
    decode.optional(decode.bool),
  )
  use variables <- decode.optional_field(
    "variables",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  decode.success(CreateStageRequest(
    cache_cluster_enabled: cache_cluster_enabled,
    cache_cluster_size: cache_cluster_size,
    canary_settings: canary_settings,
    deployment_id: deployment_id,
    description: description,
    documentation_version: documentation_version,
    rest_api_id: rest_api_id,
    stage_name: stage_name,
    tags: tags,
    tracing_enabled: tracing_enabled,
    variables: variables,
  ))
}

pub fn decode_create_stage_request_struct_params() -> decode.Decoder(
  CreateStageRequest,
) {
  use <- decode.recursive
  use cache_cluster_enabled <- decode.optional_field(
    "cacheClusterEnabled",
    option.None,
    decode.optional(decode.bool),
  )
  use cache_cluster_size <- decode.optional_field(
    "cacheClusterSize",
    option.None,
    decode.optional(decode_cache_cluster_size_enum()),
  )
  use canary_settings <- decode.optional_field(
    "canarySettings",
    option.None,
    decode.optional(decode_canary_settings_struct_params()),
  )
  use deployment_id <- decode.optional_field(
    "deploymentId",
    option.None,
    decode.optional(decode.string),
  )
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use documentation_version <- decode.optional_field(
    "documentationVersion",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use stage_name <- decode.optional_field(
    "stageName",
    option.None,
    decode.optional(decode.string),
  )
  use tags <- decode.optional_field(
    "tags",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use tracing_enabled <- decode.optional_field(
    "tracingEnabled",
    option.None,
    decode.optional(decode.bool),
  )
  use variables <- decode.optional_field(
    "variables",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  decode.success(CreateStageRequest(
    cache_cluster_enabled: cache_cluster_enabled,
    cache_cluster_size: cache_cluster_size,
    canary_settings: canary_settings,
    deployment_id: deployment_id,
    description: description,
    documentation_version: documentation_version,
    rest_api_id: rest_api_id,
    stage_name: stage_name,
    tags: tags,
    tracing_enabled: tracing_enabled,
    variables: variables,
  ))
}

pub type CanarySettings {
  CanarySettings(
    deployment_id: option.Option(String),
    percent_traffic: option.Option(json_float.SmithyFloat),
    stage_variable_overrides: option.Option(dict.Dict(String, String)),
    use_stage_cache: option.Option(Bool),
  )
}

pub fn encode_canary_settings_struct(input: CanarySettings) -> json.Json {
  let pairs = []
  let pairs = case input.deployment_id {
    option.Some(v) -> [#("deploymentId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.percent_traffic {
    option.Some(v) -> [#("percentTraffic", json_float.encode(v)), ..pairs]
    option.None -> [#("percentTraffic", json.int(0)), ..pairs]
  }
  let pairs = case input.stage_variable_overrides {
    option.Some(v) -> [
      #(
        "stageVariableOverrides",
        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.use_stage_cache {
    option.Some(v) -> [#("useStageCache", json.bool(v)), ..pairs]
    option.None -> [#("useStageCache", json.bool(False)), ..pairs]
  }
  json.object(pairs)
}

pub fn decode_canary_settings_struct() -> decode.Decoder(CanarySettings) {
  use <- decode.recursive
  use deployment_id <- decode.optional_field(
    "deploymentId",
    option.None,
    decode.optional(decode.string),
  )
  use percent_traffic <- decode.optional_field(
    "percentTraffic",
    option.None,
    decode.optional(json_float.decoder()),
  )
  use stage_variable_overrides <- decode.optional_field(
    "stageVariableOverrides",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use use_stage_cache <- decode.optional_field(
    "useStageCache",
    option.None,
    decode.optional(decode.bool),
  )
  decode.success(CanarySettings(
    deployment_id: deployment_id,
    percent_traffic: percent_traffic,
    stage_variable_overrides: stage_variable_overrides,
    use_stage_cache: use_stage_cache,
  ))
}

pub fn decode_canary_settings_struct_params() -> decode.Decoder(CanarySettings) {
  use <- decode.recursive
  use deployment_id <- decode.optional_field(
    "deploymentId",
    option.None,
    decode.optional(decode.string),
  )
  use percent_traffic <- decode.optional_field(
    "percentTraffic",
    option.None,
    decode.optional(json_float.decoder()),
  )
  use stage_variable_overrides <- decode.optional_field(
    "stageVariableOverrides",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use use_stage_cache <- decode.optional_field(
    "useStageCache",
    option.None,
    decode.optional(decode.bool),
  )
  decode.success(CanarySettings(
    deployment_id: deployment_id,
    percent_traffic: percent_traffic,
    stage_variable_overrides: stage_variable_overrides,
    use_stage_cache: use_stage_cache,
  ))
}

pub type Stage {
  Stage(
    access_log_settings: option.Option(AccessLogSettings),
    cache_cluster_enabled: option.Option(Bool),
    cache_cluster_size: option.Option(CacheClusterSize),
    cache_cluster_status: option.Option(CacheClusterStatus),
    canary_settings: option.Option(CanarySettings),
    client_certificate_id: option.Option(String),
    created_date: option.Option(json_timestamp.Timestamp),
    deployment_id: option.Option(String),
    description: option.Option(String),
    documentation_version: option.Option(String),
    last_updated_date: option.Option(json_timestamp.Timestamp),
    method_settings: option.Option(dict.Dict(String, MethodSetting)),
    stage_name: option.Option(String),
    tags: option.Option(dict.Dict(String, String)),
    tracing_enabled: option.Option(Bool),
    variables: option.Option(dict.Dict(String, String)),
    web_acl_arn: option.Option(String),
  )
}

pub fn encode_stage_struct(input: Stage) -> json.Json {
  let pairs = []
  let pairs = case input.access_log_settings {
    option.Some(v) -> [
      #("accessLogSettings", encode_access_log_settings_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.cache_cluster_enabled {
    option.Some(v) -> [#("cacheClusterEnabled", json.bool(v)), ..pairs]
    option.None -> [#("cacheClusterEnabled", json.bool(False)), ..pairs]
  }
  let pairs = case input.cache_cluster_size {
    option.Some(v) -> [
      #("cacheClusterSize", encode_cache_cluster_size_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.cache_cluster_status {
    option.Some(v) -> [
      #("cacheClusterStatus", encode_cache_cluster_status_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.canary_settings {
    option.Some(v) -> [
      #("canarySettings", encode_canary_settings_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.client_certificate_id {
    option.Some(v) -> [#("clientCertificateId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.created_date {
    option.Some(v) -> [
      #("createdDate", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.deployment_id {
    option.Some(v) -> [#("deploymentId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.description {
    option.Some(v) -> [#("description", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.documentation_version {
    option.Some(v) -> [#("documentationVersion", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.last_updated_date {
    option.Some(v) -> [
      #("lastUpdatedDate", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.method_settings {
    option.Some(v) -> [
      #(
        "methodSettings",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_method_setting_struct(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.stage_name {
    option.Some(v) -> [#("stageName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.tags {
    option.Some(v) -> [
      #(
        "tags",
        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.tracing_enabled {
    option.Some(v) -> [#("tracingEnabled", json.bool(v)), ..pairs]
    option.None -> [#("tracingEnabled", json.bool(False)), ..pairs]
  }
  let pairs = case input.variables {
    option.Some(v) -> [
      #(
        "variables",
        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.web_acl_arn {
    option.Some(v) -> [#("webAclArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_stage_struct() -> decode.Decoder(Stage) {
  use <- decode.recursive
  use access_log_settings <- decode.optional_field(
    "accessLogSettings",
    option.None,
    decode.optional(decode_access_log_settings_struct()),
  )
  use cache_cluster_enabled <- decode.optional_field(
    "cacheClusterEnabled",
    option.None,
    decode.optional(decode.bool),
  )
  use cache_cluster_size <- decode.optional_field(
    "cacheClusterSize",
    option.None,
    decode.optional(decode_cache_cluster_size_enum()),
  )
  use cache_cluster_status <- decode.optional_field(
    "cacheClusterStatus",
    option.None,
    decode.optional(decode_cache_cluster_status_enum()),
  )
  use canary_settings <- decode.optional_field(
    "canarySettings",
    option.None,
    decode.optional(decode_canary_settings_struct()),
  )
  use client_certificate_id <- decode.optional_field(
    "clientCertificateId",
    option.None,
    decode.optional(decode.string),
  )
  use created_date <- decode.optional_field(
    "createdDate",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use deployment_id <- decode.optional_field(
    "deploymentId",
    option.None,
    decode.optional(decode.string),
  )
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use documentation_version <- decode.optional_field(
    "documentationVersion",
    option.None,
    decode.optional(decode.string),
  )
  use last_updated_date <- decode.optional_field(
    "lastUpdatedDate",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use method_settings <- decode.optional_field(
    "methodSettings",
    option.None,
    decode.optional(decode.dict(decode.string, decode_method_setting_struct())),
  )
  use stage_name <- decode.optional_field(
    "stageName",
    option.None,
    decode.optional(decode.string),
  )
  use tags <- decode.optional_field(
    "tags",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use tracing_enabled <- decode.optional_field(
    "tracingEnabled",
    option.None,
    decode.optional(decode.bool),
  )
  use variables <- decode.optional_field(
    "variables",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use web_acl_arn <- decode.optional_field(
    "webAclArn",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(Stage(
    access_log_settings: access_log_settings,
    cache_cluster_enabled: cache_cluster_enabled,
    cache_cluster_size: cache_cluster_size,
    cache_cluster_status: cache_cluster_status,
    canary_settings: canary_settings,
    client_certificate_id: client_certificate_id,
    created_date: created_date,
    deployment_id: deployment_id,
    description: description,
    documentation_version: documentation_version,
    last_updated_date: last_updated_date,
    method_settings: method_settings,
    stage_name: stage_name,
    tags: tags,
    tracing_enabled: tracing_enabled,
    variables: variables,
    web_acl_arn: web_acl_arn,
  ))
}

pub fn decode_stage_struct_params() -> decode.Decoder(Stage) {
  use <- decode.recursive
  use access_log_settings <- decode.optional_field(
    "accessLogSettings",
    option.None,
    decode.optional(decode_access_log_settings_struct_params()),
  )
  use cache_cluster_enabled <- decode.optional_field(
    "cacheClusterEnabled",
    option.None,
    decode.optional(decode.bool),
  )
  use cache_cluster_size <- decode.optional_field(
    "cacheClusterSize",
    option.None,
    decode.optional(decode_cache_cluster_size_enum()),
  )
  use cache_cluster_status <- decode.optional_field(
    "cacheClusterStatus",
    option.None,
    decode.optional(decode_cache_cluster_status_enum()),
  )
  use canary_settings <- decode.optional_field(
    "canarySettings",
    option.None,
    decode.optional(decode_canary_settings_struct_params()),
  )
  use client_certificate_id <- decode.optional_field(
    "clientCertificateId",
    option.None,
    decode.optional(decode.string),
  )
  use created_date <- decode.optional_field(
    "createdDate",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use deployment_id <- decode.optional_field(
    "deploymentId",
    option.None,
    decode.optional(decode.string),
  )
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use documentation_version <- decode.optional_field(
    "documentationVersion",
    option.None,
    decode.optional(decode.string),
  )
  use last_updated_date <- decode.optional_field(
    "lastUpdatedDate",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use method_settings <- decode.optional_field(
    "methodSettings",
    option.None,
    decode.optional(decode.dict(
      decode.string,
      decode_method_setting_struct_params(),
    )),
  )
  use stage_name <- decode.optional_field(
    "stageName",
    option.None,
    decode.optional(decode.string),
  )
  use tags <- decode.optional_field(
    "tags",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use tracing_enabled <- decode.optional_field(
    "tracingEnabled",
    option.None,
    decode.optional(decode.bool),
  )
  use variables <- decode.optional_field(
    "variables",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use web_acl_arn <- decode.optional_field(
    "webAclArn",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(Stage(
    access_log_settings: access_log_settings,
    cache_cluster_enabled: cache_cluster_enabled,
    cache_cluster_size: cache_cluster_size,
    cache_cluster_status: cache_cluster_status,
    canary_settings: canary_settings,
    client_certificate_id: client_certificate_id,
    created_date: created_date,
    deployment_id: deployment_id,
    description: description,
    documentation_version: documentation_version,
    last_updated_date: last_updated_date,
    method_settings: method_settings,
    stage_name: stage_name,
    tags: tags,
    tracing_enabled: tracing_enabled,
    variables: variables,
    web_acl_arn: web_acl_arn,
  ))
}

pub type AccessLogSettings {
  AccessLogSettings(
    destination_arn: option.Option(String),
    format: option.Option(String),
  )
}

pub fn encode_access_log_settings_struct(
  input: AccessLogSettings,
) -> json.Json {
  let pairs = []
  let pairs = case input.destination_arn {
    option.Some(v) -> [#("destinationArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.format {
    option.Some(v) -> [#("format", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_access_log_settings_struct() -> decode.Decoder(AccessLogSettings) {
  use <- decode.recursive
  use destination_arn <- decode.optional_field(
    "destinationArn",
    option.None,
    decode.optional(decode.string),
  )
  use format <- decode.optional_field(
    "format",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(AccessLogSettings(
    destination_arn: destination_arn,
    format: format,
  ))
}

pub fn decode_access_log_settings_struct_params() -> decode.Decoder(
  AccessLogSettings,
) {
  use <- decode.recursive
  use destination_arn <- decode.optional_field(
    "destinationArn",
    option.None,
    decode.optional(decode.string),
  )
  use format <- decode.optional_field(
    "format",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(AccessLogSettings(
    destination_arn: destination_arn,
    format: format,
  ))
}

pub type CacheClusterStatus {
  CacheClusterStatusAvailable
  CacheClusterStatusCreateInProgress
  CacheClusterStatusDeleteInProgress
  CacheClusterStatusFlushInProgress
  CacheClusterStatusNotAvailable
}

pub fn encode_cache_cluster_status_enum(v: CacheClusterStatus) -> json.Json {
  case v {
    CacheClusterStatusAvailable -> json.string("AVAILABLE")
    CacheClusterStatusCreateInProgress -> json.string("CREATE_IN_PROGRESS")
    CacheClusterStatusDeleteInProgress -> json.string("DELETE_IN_PROGRESS")
    CacheClusterStatusFlushInProgress -> json.string("FLUSH_IN_PROGRESS")
    CacheClusterStatusNotAvailable -> json.string("NOT_AVAILABLE")
  }
}

pub fn decode_cache_cluster_status_enum() -> decode.Decoder(CacheClusterStatus) {
  decode.then(decode.string, fn(s) {
    case s {
      "AVAILABLE" -> decode.success(CacheClusterStatusAvailable)
      "CREATE_IN_PROGRESS" -> decode.success(CacheClusterStatusCreateInProgress)
      "DELETE_IN_PROGRESS" -> decode.success(CacheClusterStatusDeleteInProgress)
      "FLUSH_IN_PROGRESS" -> decode.success(CacheClusterStatusFlushInProgress)
      "NOT_AVAILABLE" -> decode.success(CacheClusterStatusNotAvailable)
      _ -> decode.failure(CacheClusterStatusAvailable, "unknown enum value")
    }
  })
}

pub fn cache_cluster_status_from_wire(
  s: String,
) -> Result(CacheClusterStatus, String) {
  case s {
    "AVAILABLE" -> Ok(CacheClusterStatusAvailable)
    "CREATE_IN_PROGRESS" -> Ok(CacheClusterStatusCreateInProgress)
    "DELETE_IN_PROGRESS" -> Ok(CacheClusterStatusDeleteInProgress)
    "FLUSH_IN_PROGRESS" -> Ok(CacheClusterStatusFlushInProgress)
    "NOT_AVAILABLE" -> Ok(CacheClusterStatusNotAvailable)
    _ -> Ok(CacheClusterStatusAvailable)
  }
}

pub type MethodSetting {
  MethodSetting(
    cache_data_encrypted: option.Option(Bool),
    cache_ttl_in_seconds: option.Option(Int),
    caching_enabled: option.Option(Bool),
    data_trace_enabled: option.Option(Bool),
    logging_level: option.Option(String),
    metrics_enabled: option.Option(Bool),
    require_authorization_for_cache_control: option.Option(Bool),
    throttling_burst_limit: option.Option(Int),
    throttling_rate_limit: option.Option(json_float.SmithyFloat),
    unauthorized_cache_control_header_strategy: option.Option(
      UnauthorizedCacheControlHeaderStrategy,
    ),
  )
}

pub fn encode_method_setting_struct(input: MethodSetting) -> json.Json {
  let pairs = []
  let pairs = case input.cache_data_encrypted {
    option.Some(v) -> [#("cacheDataEncrypted", json.bool(v)), ..pairs]
    option.None -> [#("cacheDataEncrypted", json.bool(False)), ..pairs]
  }
  let pairs = case input.cache_ttl_in_seconds {
    option.Some(v) -> [#("cacheTtlInSeconds", json.int(v)), ..pairs]
    option.None -> [#("cacheTtlInSeconds", json.int(0)), ..pairs]
  }
  let pairs = case input.caching_enabled {
    option.Some(v) -> [#("cachingEnabled", json.bool(v)), ..pairs]
    option.None -> [#("cachingEnabled", json.bool(False)), ..pairs]
  }
  let pairs = case input.data_trace_enabled {
    option.Some(v) -> [#("dataTraceEnabled", json.bool(v)), ..pairs]
    option.None -> [#("dataTraceEnabled", json.bool(False)), ..pairs]
  }
  let pairs = case input.logging_level {
    option.Some(v) -> [#("loggingLevel", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.metrics_enabled {
    option.Some(v) -> [#("metricsEnabled", json.bool(v)), ..pairs]
    option.None -> [#("metricsEnabled", json.bool(False)), ..pairs]
  }
  let pairs = case input.require_authorization_for_cache_control {
    option.Some(v) -> [
      #("requireAuthorizationForCacheControl", json.bool(v)),
      ..pairs
    ]
    option.None -> [
      #("requireAuthorizationForCacheControl", json.bool(False)),
      ..pairs
    ]
  }
  let pairs = case input.throttling_burst_limit {
    option.Some(v) -> [#("throttlingBurstLimit", json.int(v)), ..pairs]
    option.None -> [#("throttlingBurstLimit", json.int(0)), ..pairs]
  }
  let pairs = case input.throttling_rate_limit {
    option.Some(v) -> [#("throttlingRateLimit", json_float.encode(v)), ..pairs]
    option.None -> [#("throttlingRateLimit", json.int(0)), ..pairs]
  }
  let pairs = case input.unauthorized_cache_control_header_strategy {
    option.Some(v) -> [
      #(
        "unauthorizedCacheControlHeaderStrategy",
        encode_unauthorized_cache_control_header_strategy_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_method_setting_struct() -> decode.Decoder(MethodSetting) {
  use <- decode.recursive
  use cache_data_encrypted <- decode.optional_field(
    "cacheDataEncrypted",
    option.None,
    decode.optional(decode.bool),
  )
  use cache_ttl_in_seconds <- decode.optional_field(
    "cacheTtlInSeconds",
    option.None,
    decode.optional(decode.int),
  )
  use caching_enabled <- decode.optional_field(
    "cachingEnabled",
    option.None,
    decode.optional(decode.bool),
  )
  use data_trace_enabled <- decode.optional_field(
    "dataTraceEnabled",
    option.None,
    decode.optional(decode.bool),
  )
  use logging_level <- decode.optional_field(
    "loggingLevel",
    option.None,
    decode.optional(decode.string),
  )
  use metrics_enabled <- decode.optional_field(
    "metricsEnabled",
    option.None,
    decode.optional(decode.bool),
  )
  use require_authorization_for_cache_control <- decode.optional_field(
    "requireAuthorizationForCacheControl",
    option.None,
    decode.optional(decode.bool),
  )
  use throttling_burst_limit <- decode.optional_field(
    "throttlingBurstLimit",
    option.None,
    decode.optional(decode.int),
  )
  use throttling_rate_limit <- decode.optional_field(
    "throttlingRateLimit",
    option.None,
    decode.optional(json_float.decoder()),
  )
  use unauthorized_cache_control_header_strategy <- decode.optional_field(
    "unauthorizedCacheControlHeaderStrategy",
    option.None,
    decode.optional(decode_unauthorized_cache_control_header_strategy_enum()),
  )
  decode.success(MethodSetting(
    cache_data_encrypted: cache_data_encrypted,
    cache_ttl_in_seconds: cache_ttl_in_seconds,
    caching_enabled: caching_enabled,
    data_trace_enabled: data_trace_enabled,
    logging_level: logging_level,
    metrics_enabled: metrics_enabled,
    require_authorization_for_cache_control: require_authorization_for_cache_control,
    throttling_burst_limit: throttling_burst_limit,
    throttling_rate_limit: throttling_rate_limit,
    unauthorized_cache_control_header_strategy: unauthorized_cache_control_header_strategy,
  ))
}

pub fn decode_method_setting_struct_params() -> decode.Decoder(MethodSetting) {
  use <- decode.recursive
  use cache_data_encrypted <- decode.optional_field(
    "cacheDataEncrypted",
    option.None,
    decode.optional(decode.bool),
  )
  use cache_ttl_in_seconds <- decode.optional_field(
    "cacheTtlInSeconds",
    option.None,
    decode.optional(decode.int),
  )
  use caching_enabled <- decode.optional_field(
    "cachingEnabled",
    option.None,
    decode.optional(decode.bool),
  )
  use data_trace_enabled <- decode.optional_field(
    "dataTraceEnabled",
    option.None,
    decode.optional(decode.bool),
  )
  use logging_level <- decode.optional_field(
    "loggingLevel",
    option.None,
    decode.optional(decode.string),
  )
  use metrics_enabled <- decode.optional_field(
    "metricsEnabled",
    option.None,
    decode.optional(decode.bool),
  )
  use require_authorization_for_cache_control <- decode.optional_field(
    "requireAuthorizationForCacheControl",
    option.None,
    decode.optional(decode.bool),
  )
  use throttling_burst_limit <- decode.optional_field(
    "throttlingBurstLimit",
    option.None,
    decode.optional(decode.int),
  )
  use throttling_rate_limit <- decode.optional_field(
    "throttlingRateLimit",
    option.None,
    decode.optional(json_float.decoder()),
  )
  use unauthorized_cache_control_header_strategy <- decode.optional_field(
    "unauthorizedCacheControlHeaderStrategy",
    option.None,
    decode.optional(decode_unauthorized_cache_control_header_strategy_enum()),
  )
  decode.success(MethodSetting(
    cache_data_encrypted: cache_data_encrypted,
    cache_ttl_in_seconds: cache_ttl_in_seconds,
    caching_enabled: caching_enabled,
    data_trace_enabled: data_trace_enabled,
    logging_level: logging_level,
    metrics_enabled: metrics_enabled,
    require_authorization_for_cache_control: require_authorization_for_cache_control,
    throttling_burst_limit: throttling_burst_limit,
    throttling_rate_limit: throttling_rate_limit,
    unauthorized_cache_control_header_strategy: unauthorized_cache_control_header_strategy,
  ))
}

pub type UnauthorizedCacheControlHeaderStrategy {
  UnauthorizedCacheControlHeaderStrategyFailWith403
  UnauthorizedCacheControlHeaderStrategySucceedWithoutResponseHeader
  UnauthorizedCacheControlHeaderStrategySucceedWithResponseHeader
}

pub fn encode_unauthorized_cache_control_header_strategy_enum(
  v: UnauthorizedCacheControlHeaderStrategy,
) -> json.Json {
  case v {
    UnauthorizedCacheControlHeaderStrategyFailWith403 ->
      json.string("FAIL_WITH_403")
    UnauthorizedCacheControlHeaderStrategySucceedWithoutResponseHeader ->
      json.string("SUCCEED_WITHOUT_RESPONSE_HEADER")
    UnauthorizedCacheControlHeaderStrategySucceedWithResponseHeader ->
      json.string("SUCCEED_WITH_RESPONSE_HEADER")
  }
}

pub fn decode_unauthorized_cache_control_header_strategy_enum() -> decode.Decoder(
  UnauthorizedCacheControlHeaderStrategy,
) {
  decode.then(decode.string, fn(s) {
    case s {
      "FAIL_WITH_403" ->
        decode.success(UnauthorizedCacheControlHeaderStrategyFailWith403)
      "SUCCEED_WITHOUT_RESPONSE_HEADER" ->
        decode.success(
          UnauthorizedCacheControlHeaderStrategySucceedWithoutResponseHeader,
        )
      "SUCCEED_WITH_RESPONSE_HEADER" ->
        decode.success(
          UnauthorizedCacheControlHeaderStrategySucceedWithResponseHeader,
        )
      _ ->
        decode.failure(
          UnauthorizedCacheControlHeaderStrategyFailWith403,
          "unknown enum value",
        )
    }
  })
}

pub fn unauthorized_cache_control_header_strategy_from_wire(
  s: String,
) -> Result(UnauthorizedCacheControlHeaderStrategy, String) {
  case s {
    "FAIL_WITH_403" -> Ok(UnauthorizedCacheControlHeaderStrategyFailWith403)
    "SUCCEED_WITHOUT_RESPONSE_HEADER" ->
      Ok(UnauthorizedCacheControlHeaderStrategySucceedWithoutResponseHeader)
    "SUCCEED_WITH_RESPONSE_HEADER" ->
      Ok(UnauthorizedCacheControlHeaderStrategySucceedWithResponseHeader)
    _ -> Ok(UnauthorizedCacheControlHeaderStrategyFailWith403)
  }
}

pub type CreateUsagePlanRequest {
  CreateUsagePlanRequest(
    api_stages: option.Option(List(ApiStage)),
    description: option.Option(String),
    name: option.Option(String),
    quota: option.Option(QuotaSettings),
    tags: option.Option(dict.Dict(String, String)),
    throttle: option.Option(ThrottleSettings),
  )
}

pub fn encode_create_usage_plan_request_struct(
  input: CreateUsagePlanRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.api_stages {
    option.Some(v) -> [
      #("apiStages", fn(xs) { json.array(xs, encode_api_stage_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.description {
    option.Some(v) -> [#("description", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.name {
    option.Some(v) -> [#("name", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.quota {
    option.Some(v) -> [#("quota", encode_quota_settings_struct(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.tags {
    option.Some(v) -> [
      #(
        "tags",
        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.throttle {
    option.Some(v) -> [
      #("throttle", encode_throttle_settings_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_create_usage_plan_request_struct() -> decode.Decoder(
  CreateUsagePlanRequest,
) {
  use <- decode.recursive
  use api_stages <- decode.optional_field(
    "apiStages",
    option.None,
    decode.optional(decode.list(decode_api_stage_struct())),
  )
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use name <- decode.optional_field(
    "name",
    option.None,
    decode.optional(decode.string),
  )
  use quota <- decode.optional_field(
    "quota",
    option.None,
    decode.optional(decode_quota_settings_struct()),
  )
  use tags <- decode.optional_field(
    "tags",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use throttle <- decode.optional_field(
    "throttle",
    option.None,
    decode.optional(decode_throttle_settings_struct()),
  )
  decode.success(CreateUsagePlanRequest(
    api_stages: api_stages,
    description: description,
    name: name,
    quota: quota,
    tags: tags,
    throttle: throttle,
  ))
}

pub fn decode_create_usage_plan_request_struct_params() -> decode.Decoder(
  CreateUsagePlanRequest,
) {
  use <- decode.recursive
  use api_stages <- decode.optional_field(
    "apiStages",
    option.None,
    decode.optional(decode.list(decode_api_stage_struct_params())),
  )
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use name <- decode.optional_field(
    "name",
    option.None,
    decode.optional(decode.string),
  )
  use quota <- decode.optional_field(
    "quota",
    option.None,
    decode.optional(decode_quota_settings_struct_params()),
  )
  use tags <- decode.optional_field(
    "tags",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use throttle <- decode.optional_field(
    "throttle",
    option.None,
    decode.optional(decode_throttle_settings_struct_params()),
  )
  decode.success(CreateUsagePlanRequest(
    api_stages: api_stages,
    description: description,
    name: name,
    quota: quota,
    tags: tags,
    throttle: throttle,
  ))
}

pub type ApiStage {
  ApiStage(
    api_id: option.Option(String),
    stage: option.Option(String),
    throttle: option.Option(dict.Dict(String, ThrottleSettings)),
  )
}

pub fn encode_api_stage_struct(input: ApiStage) -> json.Json {
  let pairs = []
  let pairs = case input.api_id {
    option.Some(v) -> [#("apiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.stage {
    option.Some(v) -> [#("stage", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.throttle {
    option.Some(v) -> [
      #(
        "throttle",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, encode_throttle_settings_struct(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_api_stage_struct() -> decode.Decoder(ApiStage) {
  use <- decode.recursive
  use api_id <- decode.optional_field(
    "apiId",
    option.None,
    decode.optional(decode.string),
  )
  use stage <- decode.optional_field(
    "stage",
    option.None,
    decode.optional(decode.string),
  )
  use throttle <- decode.optional_field(
    "throttle",
    option.None,
    decode.optional(decode.dict(
      decode.string,
      decode_throttle_settings_struct(),
    )),
  )
  decode.success(ApiStage(api_id: api_id, stage: stage, throttle: throttle))
}

pub fn decode_api_stage_struct_params() -> decode.Decoder(ApiStage) {
  use <- decode.recursive
  use api_id <- decode.optional_field(
    "apiId",
    option.None,
    decode.optional(decode.string),
  )
  use stage <- decode.optional_field(
    "stage",
    option.None,
    decode.optional(decode.string),
  )
  use throttle <- decode.optional_field(
    "throttle",
    option.None,
    decode.optional(decode.dict(
      decode.string,
      decode_throttle_settings_struct_params(),
    )),
  )
  decode.success(ApiStage(api_id: api_id, stage: stage, throttle: throttle))
}

pub type ThrottleSettings {
  ThrottleSettings(
    burst_limit: option.Option(Int),
    rate_limit: option.Option(json_float.SmithyFloat),
  )
}

pub fn encode_throttle_settings_struct(input: ThrottleSettings) -> json.Json {
  let pairs = []
  let pairs = case input.burst_limit {
    option.Some(v) -> [#("burstLimit", json.int(v)), ..pairs]
    option.None -> [#("burstLimit", json.int(0)), ..pairs]
  }
  let pairs = case input.rate_limit {
    option.Some(v) -> [#("rateLimit", json_float.encode(v)), ..pairs]
    option.None -> [#("rateLimit", json.int(0)), ..pairs]
  }
  json.object(pairs)
}

pub fn decode_throttle_settings_struct() -> decode.Decoder(ThrottleSettings) {
  use <- decode.recursive
  use burst_limit <- decode.optional_field(
    "burstLimit",
    option.None,
    decode.optional(decode.int),
  )
  use rate_limit <- decode.optional_field(
    "rateLimit",
    option.None,
    decode.optional(json_float.decoder()),
  )
  decode.success(ThrottleSettings(
    burst_limit: burst_limit,
    rate_limit: rate_limit,
  ))
}

pub fn decode_throttle_settings_struct_params() -> decode.Decoder(
  ThrottleSettings,
) {
  use <- decode.recursive
  use burst_limit <- decode.optional_field(
    "burstLimit",
    option.None,
    decode.optional(decode.int),
  )
  use rate_limit <- decode.optional_field(
    "rateLimit",
    option.None,
    decode.optional(json_float.decoder()),
  )
  decode.success(ThrottleSettings(
    burst_limit: burst_limit,
    rate_limit: rate_limit,
  ))
}

pub type QuotaSettings {
  QuotaSettings(
    limit: option.Option(Int),
    offset: option.Option(Int),
    period: option.Option(QuotaPeriodType),
  )
}

pub fn encode_quota_settings_struct(input: QuotaSettings) -> json.Json {
  let pairs = []
  let pairs = case input.limit {
    option.Some(v) -> [#("limit", json.int(v)), ..pairs]
    option.None -> [#("limit", json.int(0)), ..pairs]
  }
  let pairs = case input.offset {
    option.Some(v) -> [#("offset", json.int(v)), ..pairs]
    option.None -> [#("offset", json.int(0)), ..pairs]
  }
  let pairs = case input.period {
    option.Some(v) -> [#("period", encode_quota_period_type_enum(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_quota_settings_struct() -> decode.Decoder(QuotaSettings) {
  use <- decode.recursive
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use offset <- decode.optional_field(
    "offset",
    option.None,
    decode.optional(decode.int),
  )
  use period <- decode.optional_field(
    "period",
    option.None,
    decode.optional(decode_quota_period_type_enum()),
  )
  decode.success(QuotaSettings(limit: limit, offset: offset, period: period))
}

pub fn decode_quota_settings_struct_params() -> decode.Decoder(QuotaSettings) {
  use <- decode.recursive
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use offset <- decode.optional_field(
    "offset",
    option.None,
    decode.optional(decode.int),
  )
  use period <- decode.optional_field(
    "period",
    option.None,
    decode.optional(decode_quota_period_type_enum()),
  )
  decode.success(QuotaSettings(limit: limit, offset: offset, period: period))
}

pub type QuotaPeriodType {
  QuotaPeriodTypeDay
  QuotaPeriodTypeMonth
  QuotaPeriodTypeWeek
}

pub fn encode_quota_period_type_enum(v: QuotaPeriodType) -> json.Json {
  case v {
    QuotaPeriodTypeDay -> json.string("DAY")
    QuotaPeriodTypeMonth -> json.string("MONTH")
    QuotaPeriodTypeWeek -> json.string("WEEK")
  }
}

pub fn decode_quota_period_type_enum() -> decode.Decoder(QuotaPeriodType) {
  decode.then(decode.string, fn(s) {
    case s {
      "DAY" -> decode.success(QuotaPeriodTypeDay)
      "MONTH" -> decode.success(QuotaPeriodTypeMonth)
      "WEEK" -> decode.success(QuotaPeriodTypeWeek)
      _ -> decode.failure(QuotaPeriodTypeDay, "unknown enum value")
    }
  })
}

pub fn quota_period_type_from_wire(
  s: String,
) -> Result(QuotaPeriodType, String) {
  case s {
    "DAY" -> Ok(QuotaPeriodTypeDay)
    "MONTH" -> Ok(QuotaPeriodTypeMonth)
    "WEEK" -> Ok(QuotaPeriodTypeWeek)
    _ -> Ok(QuotaPeriodTypeDay)
  }
}

pub type UsagePlan {
  UsagePlan(
    api_stages: option.Option(List(ApiStage)),
    description: option.Option(String),
    id: option.Option(String),
    name: option.Option(String),
    product_code: option.Option(String),
    quota: option.Option(QuotaSettings),
    tags: option.Option(dict.Dict(String, String)),
    throttle: option.Option(ThrottleSettings),
  )
}

pub fn encode_usage_plan_struct(input: UsagePlan) -> json.Json {
  let pairs = []
  let pairs = case input.api_stages {
    option.Some(v) -> [
      #("apiStages", fn(xs) { json.array(xs, encode_api_stage_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.description {
    option.Some(v) -> [#("description", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.id {
    option.Some(v) -> [#("id", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.name {
    option.Some(v) -> [#("name", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.product_code {
    option.Some(v) -> [#("productCode", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.quota {
    option.Some(v) -> [#("quota", encode_quota_settings_struct(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.tags {
    option.Some(v) -> [
      #(
        "tags",
        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.throttle {
    option.Some(v) -> [
      #("throttle", encode_throttle_settings_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_usage_plan_struct() -> decode.Decoder(UsagePlan) {
  use <- decode.recursive
  use api_stages <- decode.optional_field(
    "apiStages",
    option.None,
    decode.optional(decode.list(decode_api_stage_struct())),
  )
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use id <- decode.optional_field(
    "id",
    option.None,
    decode.optional(decode.string),
  )
  use name <- decode.optional_field(
    "name",
    option.None,
    decode.optional(decode.string),
  )
  use product_code <- decode.optional_field(
    "productCode",
    option.None,
    decode.optional(decode.string),
  )
  use quota <- decode.optional_field(
    "quota",
    option.None,
    decode.optional(decode_quota_settings_struct()),
  )
  use tags <- decode.optional_field(
    "tags",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use throttle <- decode.optional_field(
    "throttle",
    option.None,
    decode.optional(decode_throttle_settings_struct()),
  )
  decode.success(UsagePlan(
    api_stages: api_stages,
    description: description,
    id: id,
    name: name,
    product_code: product_code,
    quota: quota,
    tags: tags,
    throttle: throttle,
  ))
}

pub fn decode_usage_plan_struct_params() -> decode.Decoder(UsagePlan) {
  use <- decode.recursive
  use api_stages <- decode.optional_field(
    "apiStages",
    option.None,
    decode.optional(decode.list(decode_api_stage_struct_params())),
  )
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use id <- decode.optional_field(
    "id",
    option.None,
    decode.optional(decode.string),
  )
  use name <- decode.optional_field(
    "name",
    option.None,
    decode.optional(decode.string),
  )
  use product_code <- decode.optional_field(
    "productCode",
    option.None,
    decode.optional(decode.string),
  )
  use quota <- decode.optional_field(
    "quota",
    option.None,
    decode.optional(decode_quota_settings_struct_params()),
  )
  use tags <- decode.optional_field(
    "tags",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use throttle <- decode.optional_field(
    "throttle",
    option.None,
    decode.optional(decode_throttle_settings_struct_params()),
  )
  decode.success(UsagePlan(
    api_stages: api_stages,
    description: description,
    id: id,
    name: name,
    product_code: product_code,
    quota: quota,
    tags: tags,
    throttle: throttle,
  ))
}

pub type CreateUsagePlanKeyRequest {
  CreateUsagePlanKeyRequest(
    key_id: option.Option(String),
    key_type: option.Option(String),
    usage_plan_id: option.Option(String),
  )
}

pub fn encode_create_usage_plan_key_request_struct(
  input: CreateUsagePlanKeyRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.key_id {
    option.Some(v) -> [#("keyId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.key_type {
    option.Some(v) -> [#("keyType", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.usage_plan_id {
    option.Some(v) -> [#("usagePlanId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_create_usage_plan_key_request_struct() -> decode.Decoder(
  CreateUsagePlanKeyRequest,
) {
  use <- decode.recursive
  use key_id <- decode.optional_field(
    "keyId",
    option.None,
    decode.optional(decode.string),
  )
  use key_type <- decode.optional_field(
    "keyType",
    option.None,
    decode.optional(decode.string),
  )
  use usage_plan_id <- decode.optional_field(
    "usagePlanId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(CreateUsagePlanKeyRequest(
    key_id: key_id,
    key_type: key_type,
    usage_plan_id: usage_plan_id,
  ))
}

pub fn decode_create_usage_plan_key_request_struct_params() -> decode.Decoder(
  CreateUsagePlanKeyRequest,
) {
  use <- decode.recursive
  use key_id <- decode.optional_field(
    "keyId",
    option.None,
    decode.optional(decode.string),
  )
  use key_type <- decode.optional_field(
    "keyType",
    option.None,
    decode.optional(decode.string),
  )
  use usage_plan_id <- decode.optional_field(
    "usagePlanId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(CreateUsagePlanKeyRequest(
    key_id: key_id,
    key_type: key_type,
    usage_plan_id: usage_plan_id,
  ))
}

pub type UsagePlanKey {
  UsagePlanKey(
    id: option.Option(String),
    name: option.Option(String),
    type_: option.Option(String),
    value: option.Option(String),
  )
}

pub fn encode_usage_plan_key_struct(input: UsagePlanKey) -> json.Json {
  let pairs = []
  let pairs = case input.id {
    option.Some(v) -> [#("id", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.name {
    option.Some(v) -> [#("name", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.type_ {
    option.Some(v) -> [#("type", 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_usage_plan_key_struct() -> decode.Decoder(UsagePlanKey) {
  use <- decode.recursive
  use id <- decode.optional_field(
    "id",
    option.None,
    decode.optional(decode.string),
  )
  use name <- decode.optional_field(
    "name",
    option.None,
    decode.optional(decode.string),
  )
  use type_ <- decode.optional_field(
    "type",
    option.None,
    decode.optional(decode.string),
  )
  use value <- decode.optional_field(
    "value",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UsagePlanKey(id: id, name: name, type_: type_, value: value))
}

pub fn decode_usage_plan_key_struct_params() -> decode.Decoder(UsagePlanKey) {
  use <- decode.recursive
  use id <- decode.optional_field(
    "id",
    option.None,
    decode.optional(decode.string),
  )
  use name <- decode.optional_field(
    "name",
    option.None,
    decode.optional(decode.string),
  )
  use type_ <- decode.optional_field(
    "type",
    option.None,
    decode.optional(decode.string),
  )
  use value <- decode.optional_field(
    "value",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UsagePlanKey(id: id, name: name, type_: type_, value: value))
}

pub type CreateVpcLinkRequest {
  CreateVpcLinkRequest(
    description: option.Option(String),
    name: option.Option(String),
    tags: option.Option(dict.Dict(String, String)),
    target_arns: option.Option(List(String)),
  )
}

pub fn encode_create_vpc_link_request_struct(
  input: CreateVpcLinkRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.description {
    option.Some(v) -> [#("description", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.name {
    option.Some(v) -> [#("name", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.tags {
    option.Some(v) -> [
      #(
        "tags",
        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.target_arns {
    option.Some(v) -> [
      #("targetArns", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_create_vpc_link_request_struct() -> decode.Decoder(
  CreateVpcLinkRequest,
) {
  use <- decode.recursive
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use name <- decode.optional_field(
    "name",
    option.None,
    decode.optional(decode.string),
  )
  use tags <- decode.optional_field(
    "tags",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use target_arns <- decode.optional_field(
    "targetArns",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  decode.success(CreateVpcLinkRequest(
    description: description,
    name: name,
    tags: tags,
    target_arns: target_arns,
  ))
}

pub fn decode_create_vpc_link_request_struct_params() -> decode.Decoder(
  CreateVpcLinkRequest,
) {
  use <- decode.recursive
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use name <- decode.optional_field(
    "name",
    option.None,
    decode.optional(decode.string),
  )
  use tags <- decode.optional_field(
    "tags",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use target_arns <- decode.optional_field(
    "targetArns",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  decode.success(CreateVpcLinkRequest(
    description: description,
    name: name,
    tags: tags,
    target_arns: target_arns,
  ))
}

pub type VpcLink {
  VpcLink(
    description: option.Option(String),
    id: option.Option(String),
    name: option.Option(String),
    status: option.Option(VpcLinkStatus),
    status_message: option.Option(String),
    tags: option.Option(dict.Dict(String, String)),
    target_arns: option.Option(List(String)),
  )
}

pub fn encode_vpc_link_struct(input: VpcLink) -> json.Json {
  let pairs = []
  let pairs = case input.description {
    option.Some(v) -> [#("description", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.id {
    option.Some(v) -> [#("id", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.name {
    option.Some(v) -> [#("name", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.status {
    option.Some(v) -> [#("status", encode_vpc_link_status_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.status_message {
    option.Some(v) -> [#("statusMessage", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.tags {
    option.Some(v) -> [
      #(
        "tags",
        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.target_arns {
    option.Some(v) -> [
      #("targetArns", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_vpc_link_struct() -> decode.Decoder(VpcLink) {
  use <- decode.recursive
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use id <- decode.optional_field(
    "id",
    option.None,
    decode.optional(decode.string),
  )
  use name <- decode.optional_field(
    "name",
    option.None,
    decode.optional(decode.string),
  )
  use status <- decode.optional_field(
    "status",
    option.None,
    decode.optional(decode_vpc_link_status_enum()),
  )
  use status_message <- decode.optional_field(
    "statusMessage",
    option.None,
    decode.optional(decode.string),
  )
  use tags <- decode.optional_field(
    "tags",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use target_arns <- decode.optional_field(
    "targetArns",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  decode.success(VpcLink(
    description: description,
    id: id,
    name: name,
    status: status,
    status_message: status_message,
    tags: tags,
    target_arns: target_arns,
  ))
}

pub fn decode_vpc_link_struct_params() -> decode.Decoder(VpcLink) {
  use <- decode.recursive
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use id <- decode.optional_field(
    "id",
    option.None,
    decode.optional(decode.string),
  )
  use name <- decode.optional_field(
    "name",
    option.None,
    decode.optional(decode.string),
  )
  use status <- decode.optional_field(
    "status",
    option.None,
    decode.optional(decode_vpc_link_status_enum()),
  )
  use status_message <- decode.optional_field(
    "statusMessage",
    option.None,
    decode.optional(decode.string),
  )
  use tags <- decode.optional_field(
    "tags",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use target_arns <- decode.optional_field(
    "targetArns",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  decode.success(VpcLink(
    description: description,
    id: id,
    name: name,
    status: status,
    status_message: status_message,
    tags: tags,
    target_arns: target_arns,
  ))
}

pub type VpcLinkStatus {
  VpcLinkStatusAvailable
  VpcLinkStatusDeleting
  VpcLinkStatusFailed
  VpcLinkStatusPending
}

pub fn encode_vpc_link_status_enum(v: VpcLinkStatus) -> json.Json {
  case v {
    VpcLinkStatusAvailable -> json.string("AVAILABLE")
    VpcLinkStatusDeleting -> json.string("DELETING")
    VpcLinkStatusFailed -> json.string("FAILED")
    VpcLinkStatusPending -> json.string("PENDING")
  }
}

pub fn decode_vpc_link_status_enum() -> decode.Decoder(VpcLinkStatus) {
  decode.then(decode.string, fn(s) {
    case s {
      "AVAILABLE" -> decode.success(VpcLinkStatusAvailable)
      "DELETING" -> decode.success(VpcLinkStatusDeleting)
      "FAILED" -> decode.success(VpcLinkStatusFailed)
      "PENDING" -> decode.success(VpcLinkStatusPending)
      _ -> decode.failure(VpcLinkStatusAvailable, "unknown enum value")
    }
  })
}

pub fn vpc_link_status_from_wire(s: String) -> Result(VpcLinkStatus, String) {
  case s {
    "AVAILABLE" -> Ok(VpcLinkStatusAvailable)
    "DELETING" -> Ok(VpcLinkStatusDeleting)
    "FAILED" -> Ok(VpcLinkStatusFailed)
    "PENDING" -> Ok(VpcLinkStatusPending)
    _ -> Ok(VpcLinkStatusAvailable)
  }
}

pub type DeleteApiKeyRequest {
  DeleteApiKeyRequest(api_key: option.Option(String))
}

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

pub fn decode_delete_api_key_request_struct() -> decode.Decoder(
  DeleteApiKeyRequest,
) {
  use <- decode.recursive
  use api_key <- decode.optional_field(
    "apiKey",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteApiKeyRequest(api_key: api_key))
}

pub fn decode_delete_api_key_request_struct_params() -> decode.Decoder(
  DeleteApiKeyRequest,
) {
  use <- decode.recursive
  use api_key <- decode.optional_field(
    "apiKey",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteApiKeyRequest(api_key: api_key))
}

pub type DeleteAuthorizerRequest {
  DeleteAuthorizerRequest(
    authorizer_id: option.Option(String),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_delete_authorizer_request_struct(
  input: DeleteAuthorizerRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.authorizer_id {
    option.Some(v) -> [#("authorizerId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_delete_authorizer_request_struct() -> decode.Decoder(
  DeleteAuthorizerRequest,
) {
  use <- decode.recursive
  use authorizer_id <- decode.optional_field(
    "authorizerId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteAuthorizerRequest(
    authorizer_id: authorizer_id,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_delete_authorizer_request_struct_params() -> decode.Decoder(
  DeleteAuthorizerRequest,
) {
  use <- decode.recursive
  use authorizer_id <- decode.optional_field(
    "authorizerId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteAuthorizerRequest(
    authorizer_id: authorizer_id,
    rest_api_id: rest_api_id,
  ))
}

pub type DeleteBasePathMappingRequest {
  DeleteBasePathMappingRequest(
    base_path: option.Option(String),
    domain_name: option.Option(String),
    domain_name_id: option.Option(String),
  )
}

pub fn encode_delete_base_path_mapping_request_struct(
  input: DeleteBasePathMappingRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.base_path {
    option.Some(v) -> [#("basePath", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.domain_name {
    option.Some(v) -> [#("domainName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.domain_name_id {
    option.Some(v) -> [#("domainNameId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_delete_base_path_mapping_request_struct() -> decode.Decoder(
  DeleteBasePathMappingRequest,
) {
  use <- decode.recursive
  use base_path <- decode.optional_field(
    "basePath",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name <- decode.optional_field(
    "domainName",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name_id <- decode.optional_field(
    "domainNameId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteBasePathMappingRequest(
    base_path: base_path,
    domain_name: domain_name,
    domain_name_id: domain_name_id,
  ))
}

pub fn decode_delete_base_path_mapping_request_struct_params() -> decode.Decoder(
  DeleteBasePathMappingRequest,
) {
  use <- decode.recursive
  use base_path <- decode.optional_field(
    "basePath",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name <- decode.optional_field(
    "domainName",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name_id <- decode.optional_field(
    "domainNameId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteBasePathMappingRequest(
    base_path: base_path,
    domain_name: domain_name,
    domain_name_id: domain_name_id,
  ))
}

pub type DeleteClientCertificateRequest {
  DeleteClientCertificateRequest(client_certificate_id: option.Option(String))
}

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

pub fn decode_delete_client_certificate_request_struct() -> decode.Decoder(
  DeleteClientCertificateRequest,
) {
  use <- decode.recursive
  use client_certificate_id <- decode.optional_field(
    "clientCertificateId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteClientCertificateRequest(
    client_certificate_id: client_certificate_id,
  ))
}

pub fn decode_delete_client_certificate_request_struct_params() -> decode.Decoder(
  DeleteClientCertificateRequest,
) {
  use <- decode.recursive
  use client_certificate_id <- decode.optional_field(
    "clientCertificateId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteClientCertificateRequest(
    client_certificate_id: client_certificate_id,
  ))
}

pub type DeleteDeploymentRequest {
  DeleteDeploymentRequest(
    deployment_id: option.Option(String),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_delete_deployment_request_struct(
  input: DeleteDeploymentRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.deployment_id {
    option.Some(v) -> [#("deploymentId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_delete_deployment_request_struct() -> decode.Decoder(
  DeleteDeploymentRequest,
) {
  use <- decode.recursive
  use deployment_id <- decode.optional_field(
    "deploymentId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteDeploymentRequest(
    deployment_id: deployment_id,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_delete_deployment_request_struct_params() -> decode.Decoder(
  DeleteDeploymentRequest,
) {
  use <- decode.recursive
  use deployment_id <- decode.optional_field(
    "deploymentId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteDeploymentRequest(
    deployment_id: deployment_id,
    rest_api_id: rest_api_id,
  ))
}

pub type DeleteDocumentationPartRequest {
  DeleteDocumentationPartRequest(
    documentation_part_id: option.Option(String),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_delete_documentation_part_request_struct(
  input: DeleteDocumentationPartRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.documentation_part_id {
    option.Some(v) -> [#("documentationPartId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_delete_documentation_part_request_struct() -> decode.Decoder(
  DeleteDocumentationPartRequest,
) {
  use <- decode.recursive
  use documentation_part_id <- decode.optional_field(
    "documentationPartId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteDocumentationPartRequest(
    documentation_part_id: documentation_part_id,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_delete_documentation_part_request_struct_params() -> decode.Decoder(
  DeleteDocumentationPartRequest,
) {
  use <- decode.recursive
  use documentation_part_id <- decode.optional_field(
    "documentationPartId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteDocumentationPartRequest(
    documentation_part_id: documentation_part_id,
    rest_api_id: rest_api_id,
  ))
}

pub type DeleteDocumentationVersionRequest {
  DeleteDocumentationVersionRequest(
    documentation_version: option.Option(String),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_delete_documentation_version_request_struct(
  input: DeleteDocumentationVersionRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.documentation_version {
    option.Some(v) -> [#("documentationVersion", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_delete_documentation_version_request_struct() -> decode.Decoder(
  DeleteDocumentationVersionRequest,
) {
  use <- decode.recursive
  use documentation_version <- decode.optional_field(
    "documentationVersion",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteDocumentationVersionRequest(
    documentation_version: documentation_version,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_delete_documentation_version_request_struct_params() -> decode.Decoder(
  DeleteDocumentationVersionRequest,
) {
  use <- decode.recursive
  use documentation_version <- decode.optional_field(
    "documentationVersion",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteDocumentationVersionRequest(
    documentation_version: documentation_version,
    rest_api_id: rest_api_id,
  ))
}

pub type DeleteDomainNameRequest {
  DeleteDomainNameRequest(
    domain_name: option.Option(String),
    domain_name_id: option.Option(String),
  )
}

pub fn encode_delete_domain_name_request_struct(
  input: DeleteDomainNameRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.domain_name {
    option.Some(v) -> [#("domainName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.domain_name_id {
    option.Some(v) -> [#("domainNameId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_delete_domain_name_request_struct() -> decode.Decoder(
  DeleteDomainNameRequest,
) {
  use <- decode.recursive
  use domain_name <- decode.optional_field(
    "domainName",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name_id <- decode.optional_field(
    "domainNameId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteDomainNameRequest(
    domain_name: domain_name,
    domain_name_id: domain_name_id,
  ))
}

pub fn decode_delete_domain_name_request_struct_params() -> decode.Decoder(
  DeleteDomainNameRequest,
) {
  use <- decode.recursive
  use domain_name <- decode.optional_field(
    "domainName",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name_id <- decode.optional_field(
    "domainNameId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteDomainNameRequest(
    domain_name: domain_name,
    domain_name_id: domain_name_id,
  ))
}

pub type DeleteDomainNameAccessAssociationRequest {
  DeleteDomainNameAccessAssociationRequest(
    domain_name_access_association_arn: option.Option(String),
  )
}

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

pub fn decode_delete_domain_name_access_association_request_struct() -> decode.Decoder(
  DeleteDomainNameAccessAssociationRequest,
) {
  use <- decode.recursive
  use domain_name_access_association_arn <- decode.optional_field(
    "domainNameAccessAssociationArn",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteDomainNameAccessAssociationRequest(
    domain_name_access_association_arn: domain_name_access_association_arn,
  ))
}

pub fn decode_delete_domain_name_access_association_request_struct_params() -> decode.Decoder(
  DeleteDomainNameAccessAssociationRequest,
) {
  use <- decode.recursive
  use domain_name_access_association_arn <- decode.optional_field(
    "domainNameAccessAssociationArn",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteDomainNameAccessAssociationRequest(
    domain_name_access_association_arn: domain_name_access_association_arn,
  ))
}

pub type DeleteGatewayResponseRequest {
  DeleteGatewayResponseRequest(
    response_type: option.Option(GatewayResponseType),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_delete_gateway_response_request_struct(
  input: DeleteGatewayResponseRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.response_type {
    option.Some(v) -> [
      #("responseType", encode_gateway_response_type_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_delete_gateway_response_request_struct() -> decode.Decoder(
  DeleteGatewayResponseRequest,
) {
  use <- decode.recursive
  use response_type <- decode.optional_field(
    "responseType",
    option.None,
    decode.optional(decode_gateway_response_type_enum()),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteGatewayResponseRequest(
    response_type: response_type,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_delete_gateway_response_request_struct_params() -> decode.Decoder(
  DeleteGatewayResponseRequest,
) {
  use <- decode.recursive
  use response_type <- decode.optional_field(
    "responseType",
    option.None,
    decode.optional(decode_gateway_response_type_enum()),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteGatewayResponseRequest(
    response_type: response_type,
    rest_api_id: rest_api_id,
  ))
}

pub type GatewayResponseType {
  GatewayResponseTypeAccessDenied
  GatewayResponseTypeApiConfigurationError
  GatewayResponseTypeAuthorizerConfigurationError
  GatewayResponseTypeAuthorizerFailure
  GatewayResponseTypeBadRequestBody
  GatewayResponseTypeBadRequestParameters
  GatewayResponseTypeDefault4xx
  GatewayResponseTypeDefault5xx
  GatewayResponseTypeExpiredToken
  GatewayResponseTypeIntegrationFailure
  GatewayResponseTypeIntegrationTimeout
  GatewayResponseTypeInvalidApiKey
  GatewayResponseTypeInvalidSignature
  GatewayResponseTypeMissingAuthenticationToken
  GatewayResponseTypeQuotaExceeded
  GatewayResponseTypeRequestTooLarge
  GatewayResponseTypeResourceNotFound
  GatewayResponseTypeThrottled
  GatewayResponseTypeUnauthorized
  GatewayResponseTypeUnsupportedMediaType
  GatewayResponseTypeWafFiltered
}

pub fn encode_gateway_response_type_enum(v: GatewayResponseType) -> json.Json {
  case v {
    GatewayResponseTypeAccessDenied -> json.string("ACCESS_DENIED")
    GatewayResponseTypeApiConfigurationError ->
      json.string("API_CONFIGURATION_ERROR")
    GatewayResponseTypeAuthorizerConfigurationError ->
      json.string("AUTHORIZER_CONFIGURATION_ERROR")
    GatewayResponseTypeAuthorizerFailure -> json.string("AUTHORIZER_FAILURE")
    GatewayResponseTypeBadRequestBody -> json.string("BAD_REQUEST_BODY")
    GatewayResponseTypeBadRequestParameters ->
      json.string("BAD_REQUEST_PARAMETERS")
    GatewayResponseTypeDefault4xx -> json.string("DEFAULT_4XX")
    GatewayResponseTypeDefault5xx -> json.string("DEFAULT_5XX")
    GatewayResponseTypeExpiredToken -> json.string("EXPIRED_TOKEN")
    GatewayResponseTypeIntegrationFailure -> json.string("INTEGRATION_FAILURE")
    GatewayResponseTypeIntegrationTimeout -> json.string("INTEGRATION_TIMEOUT")
    GatewayResponseTypeInvalidApiKey -> json.string("INVALID_API_KEY")
    GatewayResponseTypeInvalidSignature -> json.string("INVALID_SIGNATURE")
    GatewayResponseTypeMissingAuthenticationToken ->
      json.string("MISSING_AUTHENTICATION_TOKEN")
    GatewayResponseTypeQuotaExceeded -> json.string("QUOTA_EXCEEDED")
    GatewayResponseTypeRequestTooLarge -> json.string("REQUEST_TOO_LARGE")
    GatewayResponseTypeResourceNotFound -> json.string("RESOURCE_NOT_FOUND")
    GatewayResponseTypeThrottled -> json.string("THROTTLED")
    GatewayResponseTypeUnauthorized -> json.string("UNAUTHORIZED")
    GatewayResponseTypeUnsupportedMediaType ->
      json.string("UNSUPPORTED_MEDIA_TYPE")
    GatewayResponseTypeWafFiltered -> json.string("WAF_FILTERED")
  }
}

pub fn decode_gateway_response_type_enum() -> decode.Decoder(
  GatewayResponseType,
) {
  decode.then(decode.string, fn(s) {
    case s {
      "ACCESS_DENIED" -> decode.success(GatewayResponseTypeAccessDenied)
      "API_CONFIGURATION_ERROR" ->
        decode.success(GatewayResponseTypeApiConfigurationError)
      "AUTHORIZER_CONFIGURATION_ERROR" ->
        decode.success(GatewayResponseTypeAuthorizerConfigurationError)
      "AUTHORIZER_FAILURE" ->
        decode.success(GatewayResponseTypeAuthorizerFailure)
      "BAD_REQUEST_BODY" -> decode.success(GatewayResponseTypeBadRequestBody)
      "BAD_REQUEST_PARAMETERS" ->
        decode.success(GatewayResponseTypeBadRequestParameters)
      "DEFAULT_4XX" -> decode.success(GatewayResponseTypeDefault4xx)
      "DEFAULT_5XX" -> decode.success(GatewayResponseTypeDefault5xx)
      "EXPIRED_TOKEN" -> decode.success(GatewayResponseTypeExpiredToken)
      "INTEGRATION_FAILURE" ->
        decode.success(GatewayResponseTypeIntegrationFailure)
      "INTEGRATION_TIMEOUT" ->
        decode.success(GatewayResponseTypeIntegrationTimeout)
      "INVALID_API_KEY" -> decode.success(GatewayResponseTypeInvalidApiKey)
      "INVALID_SIGNATURE" -> decode.success(GatewayResponseTypeInvalidSignature)
      "MISSING_AUTHENTICATION_TOKEN" ->
        decode.success(GatewayResponseTypeMissingAuthenticationToken)
      "QUOTA_EXCEEDED" -> decode.success(GatewayResponseTypeQuotaExceeded)
      "REQUEST_TOO_LARGE" -> decode.success(GatewayResponseTypeRequestTooLarge)
      "RESOURCE_NOT_FOUND" ->
        decode.success(GatewayResponseTypeResourceNotFound)
      "THROTTLED" -> decode.success(GatewayResponseTypeThrottled)
      "UNAUTHORIZED" -> decode.success(GatewayResponseTypeUnauthorized)
      "UNSUPPORTED_MEDIA_TYPE" ->
        decode.success(GatewayResponseTypeUnsupportedMediaType)
      "WAF_FILTERED" -> decode.success(GatewayResponseTypeWafFiltered)
      _ -> decode.failure(GatewayResponseTypeAccessDenied, "unknown enum value")
    }
  })
}

pub fn gateway_response_type_from_wire(
  s: String,
) -> Result(GatewayResponseType, String) {
  case s {
    "ACCESS_DENIED" -> Ok(GatewayResponseTypeAccessDenied)
    "API_CONFIGURATION_ERROR" -> Ok(GatewayResponseTypeApiConfigurationError)
    "AUTHORIZER_CONFIGURATION_ERROR" ->
      Ok(GatewayResponseTypeAuthorizerConfigurationError)
    "AUTHORIZER_FAILURE" -> Ok(GatewayResponseTypeAuthorizerFailure)
    "BAD_REQUEST_BODY" -> Ok(GatewayResponseTypeBadRequestBody)
    "BAD_REQUEST_PARAMETERS" -> Ok(GatewayResponseTypeBadRequestParameters)
    "DEFAULT_4XX" -> Ok(GatewayResponseTypeDefault4xx)
    "DEFAULT_5XX" -> Ok(GatewayResponseTypeDefault5xx)
    "EXPIRED_TOKEN" -> Ok(GatewayResponseTypeExpiredToken)
    "INTEGRATION_FAILURE" -> Ok(GatewayResponseTypeIntegrationFailure)
    "INTEGRATION_TIMEOUT" -> Ok(GatewayResponseTypeIntegrationTimeout)
    "INVALID_API_KEY" -> Ok(GatewayResponseTypeInvalidApiKey)
    "INVALID_SIGNATURE" -> Ok(GatewayResponseTypeInvalidSignature)
    "MISSING_AUTHENTICATION_TOKEN" ->
      Ok(GatewayResponseTypeMissingAuthenticationToken)
    "QUOTA_EXCEEDED" -> Ok(GatewayResponseTypeQuotaExceeded)
    "REQUEST_TOO_LARGE" -> Ok(GatewayResponseTypeRequestTooLarge)
    "RESOURCE_NOT_FOUND" -> Ok(GatewayResponseTypeResourceNotFound)
    "THROTTLED" -> Ok(GatewayResponseTypeThrottled)
    "UNAUTHORIZED" -> Ok(GatewayResponseTypeUnauthorized)
    "UNSUPPORTED_MEDIA_TYPE" -> Ok(GatewayResponseTypeUnsupportedMediaType)
    "WAF_FILTERED" -> Ok(GatewayResponseTypeWafFiltered)
    _ -> Ok(GatewayResponseTypeAccessDenied)
  }
}

pub type DeleteIntegrationRequest {
  DeleteIntegrationRequest(
    http_method: option.Option(String),
    resource_id: option.Option(String),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_delete_integration_request_struct(
  input: DeleteIntegrationRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.http_method {
    option.Some(v) -> [#("httpMethod", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.resource_id {
    option.Some(v) -> [#("resourceId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_delete_integration_request_struct() -> decode.Decoder(
  DeleteIntegrationRequest,
) {
  use <- decode.recursive
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteIntegrationRequest(
    http_method: http_method,
    resource_id: resource_id,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_delete_integration_request_struct_params() -> decode.Decoder(
  DeleteIntegrationRequest,
) {
  use <- decode.recursive
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteIntegrationRequest(
    http_method: http_method,
    resource_id: resource_id,
    rest_api_id: rest_api_id,
  ))
}

pub type DeleteIntegrationResponseRequest {
  DeleteIntegrationResponseRequest(
    http_method: option.Option(String),
    resource_id: option.Option(String),
    rest_api_id: option.Option(String),
    status_code: option.Option(String),
  )
}

pub fn encode_delete_integration_response_request_struct(
  input: DeleteIntegrationResponseRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.http_method {
    option.Some(v) -> [#("httpMethod", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.resource_id {
    option.Some(v) -> [#("resourceId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.status_code {
    option.Some(v) -> [#("statusCode", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_delete_integration_response_request_struct() -> decode.Decoder(
  DeleteIntegrationResponseRequest,
) {
  use <- decode.recursive
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use status_code <- decode.optional_field(
    "statusCode",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteIntegrationResponseRequest(
    http_method: http_method,
    resource_id: resource_id,
    rest_api_id: rest_api_id,
    status_code: status_code,
  ))
}

pub fn decode_delete_integration_response_request_struct_params() -> decode.Decoder(
  DeleteIntegrationResponseRequest,
) {
  use <- decode.recursive
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use status_code <- decode.optional_field(
    "statusCode",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteIntegrationResponseRequest(
    http_method: http_method,
    resource_id: resource_id,
    rest_api_id: rest_api_id,
    status_code: status_code,
  ))
}

pub type DeleteMethodRequest {
  DeleteMethodRequest(
    http_method: option.Option(String),
    resource_id: option.Option(String),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_delete_method_request_struct(
  input: DeleteMethodRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.http_method {
    option.Some(v) -> [#("httpMethod", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.resource_id {
    option.Some(v) -> [#("resourceId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_delete_method_request_struct() -> decode.Decoder(
  DeleteMethodRequest,
) {
  use <- decode.recursive
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteMethodRequest(
    http_method: http_method,
    resource_id: resource_id,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_delete_method_request_struct_params() -> decode.Decoder(
  DeleteMethodRequest,
) {
  use <- decode.recursive
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteMethodRequest(
    http_method: http_method,
    resource_id: resource_id,
    rest_api_id: rest_api_id,
  ))
}

pub type DeleteMethodResponseRequest {
  DeleteMethodResponseRequest(
    http_method: option.Option(String),
    resource_id: option.Option(String),
    rest_api_id: option.Option(String),
    status_code: option.Option(String),
  )
}

pub fn encode_delete_method_response_request_struct(
  input: DeleteMethodResponseRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.http_method {
    option.Some(v) -> [#("httpMethod", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.resource_id {
    option.Some(v) -> [#("resourceId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.status_code {
    option.Some(v) -> [#("statusCode", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_delete_method_response_request_struct() -> decode.Decoder(
  DeleteMethodResponseRequest,
) {
  use <- decode.recursive
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use status_code <- decode.optional_field(
    "statusCode",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteMethodResponseRequest(
    http_method: http_method,
    resource_id: resource_id,
    rest_api_id: rest_api_id,
    status_code: status_code,
  ))
}

pub fn decode_delete_method_response_request_struct_params() -> decode.Decoder(
  DeleteMethodResponseRequest,
) {
  use <- decode.recursive
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use status_code <- decode.optional_field(
    "statusCode",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteMethodResponseRequest(
    http_method: http_method,
    resource_id: resource_id,
    rest_api_id: rest_api_id,
    status_code: status_code,
  ))
}

pub type DeleteModelRequest {
  DeleteModelRequest(
    model_name: option.Option(String),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_delete_model_request_struct(
  input: DeleteModelRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.model_name {
    option.Some(v) -> [#("modelName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_delete_model_request_struct() -> decode.Decoder(
  DeleteModelRequest,
) {
  use <- decode.recursive
  use model_name <- decode.optional_field(
    "modelName",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteModelRequest(
    model_name: model_name,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_delete_model_request_struct_params() -> decode.Decoder(
  DeleteModelRequest,
) {
  use <- decode.recursive
  use model_name <- decode.optional_field(
    "modelName",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteModelRequest(
    model_name: model_name,
    rest_api_id: rest_api_id,
  ))
}

pub type DeleteRequestValidatorRequest {
  DeleteRequestValidatorRequest(
    request_validator_id: option.Option(String),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_delete_request_validator_request_struct(
  input: DeleteRequestValidatorRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.request_validator_id {
    option.Some(v) -> [#("requestValidatorId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_delete_request_validator_request_struct() -> decode.Decoder(
  DeleteRequestValidatorRequest,
) {
  use <- decode.recursive
  use request_validator_id <- decode.optional_field(
    "requestValidatorId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteRequestValidatorRequest(
    request_validator_id: request_validator_id,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_delete_request_validator_request_struct_params() -> decode.Decoder(
  DeleteRequestValidatorRequest,
) {
  use <- decode.recursive
  use request_validator_id <- decode.optional_field(
    "requestValidatorId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteRequestValidatorRequest(
    request_validator_id: request_validator_id,
    rest_api_id: rest_api_id,
  ))
}

pub type DeleteResourceRequest {
  DeleteResourceRequest(
    resource_id: option.Option(String),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_delete_resource_request_struct(
  input: DeleteResourceRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.resource_id {
    option.Some(v) -> [#("resourceId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_delete_resource_request_struct() -> decode.Decoder(
  DeleteResourceRequest,
) {
  use <- decode.recursive
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteResourceRequest(
    resource_id: resource_id,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_delete_resource_request_struct_params() -> decode.Decoder(
  DeleteResourceRequest,
) {
  use <- decode.recursive
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteResourceRequest(
    resource_id: resource_id,
    rest_api_id: rest_api_id,
  ))
}

pub type DeleteRestApiRequest {
  DeleteRestApiRequest(rest_api_id: option.Option(String))
}

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

pub fn decode_delete_rest_api_request_struct() -> decode.Decoder(
  DeleteRestApiRequest,
) {
  use <- decode.recursive
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteRestApiRequest(rest_api_id: rest_api_id))
}

pub fn decode_delete_rest_api_request_struct_params() -> decode.Decoder(
  DeleteRestApiRequest,
) {
  use <- decode.recursive
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteRestApiRequest(rest_api_id: rest_api_id))
}

pub type DeleteStageRequest {
  DeleteStageRequest(
    rest_api_id: option.Option(String),
    stage_name: option.Option(String),
  )
}

pub fn encode_delete_stage_request_struct(
  input: DeleteStageRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.stage_name {
    option.Some(v) -> [#("stageName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_delete_stage_request_struct() -> decode.Decoder(
  DeleteStageRequest,
) {
  use <- decode.recursive
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use stage_name <- decode.optional_field(
    "stageName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteStageRequest(
    rest_api_id: rest_api_id,
    stage_name: stage_name,
  ))
}

pub fn decode_delete_stage_request_struct_params() -> decode.Decoder(
  DeleteStageRequest,
) {
  use <- decode.recursive
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use stage_name <- decode.optional_field(
    "stageName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteStageRequest(
    rest_api_id: rest_api_id,
    stage_name: stage_name,
  ))
}

pub type DeleteUsagePlanRequest {
  DeleteUsagePlanRequest(usage_plan_id: option.Option(String))
}

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

pub fn decode_delete_usage_plan_request_struct() -> decode.Decoder(
  DeleteUsagePlanRequest,
) {
  use <- decode.recursive
  use usage_plan_id <- decode.optional_field(
    "usagePlanId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteUsagePlanRequest(usage_plan_id: usage_plan_id))
}

pub fn decode_delete_usage_plan_request_struct_params() -> decode.Decoder(
  DeleteUsagePlanRequest,
) {
  use <- decode.recursive
  use usage_plan_id <- decode.optional_field(
    "usagePlanId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteUsagePlanRequest(usage_plan_id: usage_plan_id))
}

pub type DeleteUsagePlanKeyRequest {
  DeleteUsagePlanKeyRequest(
    key_id: option.Option(String),
    usage_plan_id: option.Option(String),
  )
}

pub fn encode_delete_usage_plan_key_request_struct(
  input: DeleteUsagePlanKeyRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.key_id {
    option.Some(v) -> [#("keyId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.usage_plan_id {
    option.Some(v) -> [#("usagePlanId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_delete_usage_plan_key_request_struct() -> decode.Decoder(
  DeleteUsagePlanKeyRequest,
) {
  use <- decode.recursive
  use key_id <- decode.optional_field(
    "keyId",
    option.None,
    decode.optional(decode.string),
  )
  use usage_plan_id <- decode.optional_field(
    "usagePlanId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteUsagePlanKeyRequest(
    key_id: key_id,
    usage_plan_id: usage_plan_id,
  ))
}

pub fn decode_delete_usage_plan_key_request_struct_params() -> decode.Decoder(
  DeleteUsagePlanKeyRequest,
) {
  use <- decode.recursive
  use key_id <- decode.optional_field(
    "keyId",
    option.None,
    decode.optional(decode.string),
  )
  use usage_plan_id <- decode.optional_field(
    "usagePlanId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteUsagePlanKeyRequest(
    key_id: key_id,
    usage_plan_id: usage_plan_id,
  ))
}

pub type DeleteVpcLinkRequest {
  DeleteVpcLinkRequest(vpc_link_id: option.Option(String))
}

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

pub fn decode_delete_vpc_link_request_struct() -> decode.Decoder(
  DeleteVpcLinkRequest,
) {
  use <- decode.recursive
  use vpc_link_id <- decode.optional_field(
    "vpcLinkId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteVpcLinkRequest(vpc_link_id: vpc_link_id))
}

pub fn decode_delete_vpc_link_request_struct_params() -> decode.Decoder(
  DeleteVpcLinkRequest,
) {
  use <- decode.recursive
  use vpc_link_id <- decode.optional_field(
    "vpcLinkId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DeleteVpcLinkRequest(vpc_link_id: vpc_link_id))
}

pub type FlushStageAuthorizersCacheRequest {
  FlushStageAuthorizersCacheRequest(
    rest_api_id: option.Option(String),
    stage_name: option.Option(String),
  )
}

pub fn encode_flush_stage_authorizers_cache_request_struct(
  input: FlushStageAuthorizersCacheRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.stage_name {
    option.Some(v) -> [#("stageName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_flush_stage_authorizers_cache_request_struct() -> decode.Decoder(
  FlushStageAuthorizersCacheRequest,
) {
  use <- decode.recursive
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use stage_name <- decode.optional_field(
    "stageName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(FlushStageAuthorizersCacheRequest(
    rest_api_id: rest_api_id,
    stage_name: stage_name,
  ))
}

pub fn decode_flush_stage_authorizers_cache_request_struct_params() -> decode.Decoder(
  FlushStageAuthorizersCacheRequest,
) {
  use <- decode.recursive
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use stage_name <- decode.optional_field(
    "stageName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(FlushStageAuthorizersCacheRequest(
    rest_api_id: rest_api_id,
    stage_name: stage_name,
  ))
}

pub type FlushStageCacheRequest {
  FlushStageCacheRequest(
    rest_api_id: option.Option(String),
    stage_name: option.Option(String),
  )
}

pub fn encode_flush_stage_cache_request_struct(
  input: FlushStageCacheRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.stage_name {
    option.Some(v) -> [#("stageName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_flush_stage_cache_request_struct() -> decode.Decoder(
  FlushStageCacheRequest,
) {
  use <- decode.recursive
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use stage_name <- decode.optional_field(
    "stageName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(FlushStageCacheRequest(
    rest_api_id: rest_api_id,
    stage_name: stage_name,
  ))
}

pub fn decode_flush_stage_cache_request_struct_params() -> decode.Decoder(
  FlushStageCacheRequest,
) {
  use <- decode.recursive
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use stage_name <- decode.optional_field(
    "stageName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(FlushStageCacheRequest(
    rest_api_id: rest_api_id,
    stage_name: stage_name,
  ))
}

pub type GenerateClientCertificateRequest {
  GenerateClientCertificateRequest(
    description: option.Option(String),
    tags: option.Option(dict.Dict(String, String)),
  )
}

pub fn encode_generate_client_certificate_request_struct(
  input: GenerateClientCertificateRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.description {
    option.Some(v) -> [#("description", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.tags {
    option.Some(v) -> [
      #(
        "tags",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_generate_client_certificate_request_struct() -> decode.Decoder(
  GenerateClientCertificateRequest,
) {
  use <- decode.recursive
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use tags <- decode.optional_field(
    "tags",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  decode.success(GenerateClientCertificateRequest(
    description: description,
    tags: tags,
  ))
}

pub fn decode_generate_client_certificate_request_struct_params() -> decode.Decoder(
  GenerateClientCertificateRequest,
) {
  use <- decode.recursive
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use tags <- decode.optional_field(
    "tags",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  decode.success(GenerateClientCertificateRequest(
    description: description,
    tags: tags,
  ))
}

pub type ClientCertificate {
  ClientCertificate(
    client_certificate_id: option.Option(String),
    created_date: option.Option(json_timestamp.Timestamp),
    description: option.Option(String),
    expiration_date: option.Option(json_timestamp.Timestamp),
    pem_encoded_certificate: option.Option(String),
    tags: option.Option(dict.Dict(String, String)),
  )
}

pub fn encode_client_certificate_struct(input: ClientCertificate) -> json.Json {
  let pairs = []
  let pairs = case input.client_certificate_id {
    option.Some(v) -> [#("clientCertificateId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.created_date {
    option.Some(v) -> [
      #("createdDate", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.description {
    option.Some(v) -> [#("description", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.expiration_date {
    option.Some(v) -> [
      #("expirationDate", json_timestamp.encode_epoch_seconds(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.pem_encoded_certificate {
    option.Some(v) -> [#("pemEncodedCertificate", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.tags {
    option.Some(v) -> [
      #(
        "tags",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_client_certificate_struct() -> decode.Decoder(ClientCertificate) {
  use <- decode.recursive
  use client_certificate_id <- decode.optional_field(
    "clientCertificateId",
    option.None,
    decode.optional(decode.string),
  )
  use created_date <- decode.optional_field(
    "createdDate",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use expiration_date <- decode.optional_field(
    "expirationDate",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use pem_encoded_certificate <- decode.optional_field(
    "pemEncodedCertificate",
    option.None,
    decode.optional(decode.string),
  )
  use tags <- decode.optional_field(
    "tags",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  decode.success(ClientCertificate(
    client_certificate_id: client_certificate_id,
    created_date: created_date,
    description: description,
    expiration_date: expiration_date,
    pem_encoded_certificate: pem_encoded_certificate,
    tags: tags,
  ))
}

pub fn decode_client_certificate_struct_params() -> decode.Decoder(
  ClientCertificate,
) {
  use <- decode.recursive
  use client_certificate_id <- decode.optional_field(
    "clientCertificateId",
    option.None,
    decode.optional(decode.string),
  )
  use created_date <- decode.optional_field(
    "createdDate",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use expiration_date <- decode.optional_field(
    "expirationDate",
    option.None,
    decode.optional(json_timestamp.decoder_precise()),
  )
  use pem_encoded_certificate <- decode.optional_field(
    "pemEncodedCertificate",
    option.None,
    decode.optional(decode.string),
  )
  use tags <- decode.optional_field(
    "tags",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  decode.success(ClientCertificate(
    client_certificate_id: client_certificate_id,
    created_date: created_date,
    description: description,
    expiration_date: expiration_date,
    pem_encoded_certificate: pem_encoded_certificate,
    tags: tags,
  ))
}

pub type GetAccountRequest {
  GetAccountRequest
}

pub fn encode_get_account_request_struct(_v: GetAccountRequest) -> json.Json {
  json.object([])
}

pub fn decode_get_account_request_struct() -> decode.Decoder(GetAccountRequest) {
  decode.success(GetAccountRequest)
}

pub fn decode_get_account_request_struct_params() -> decode.Decoder(
  GetAccountRequest,
) {
  decode.success(GetAccountRequest)
}

pub type Account {
  Account(
    api_key_version: option.Option(String),
    cloudwatch_role_arn: option.Option(String),
    features: option.Option(List(String)),
    throttle_settings: option.Option(ThrottleSettings),
  )
}

pub fn encode_account_struct(input: Account) -> json.Json {
  let pairs = []
  let pairs = case input.api_key_version {
    option.Some(v) -> [#("apiKeyVersion", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.cloudwatch_role_arn {
    option.Some(v) -> [#("cloudwatchRoleArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.features {
    option.Some(v) -> [
      #("features", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.throttle_settings {
    option.Some(v) -> [
      #("throttleSettings", encode_throttle_settings_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_account_struct() -> decode.Decoder(Account) {
  use <- decode.recursive
  use api_key_version <- decode.optional_field(
    "apiKeyVersion",
    option.None,
    decode.optional(decode.string),
  )
  use cloudwatch_role_arn <- decode.optional_field(
    "cloudwatchRoleArn",
    option.None,
    decode.optional(decode.string),
  )
  use features <- decode.optional_field(
    "features",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  use throttle_settings <- decode.optional_field(
    "throttleSettings",
    option.None,
    decode.optional(decode_throttle_settings_struct()),
  )
  decode.success(Account(
    api_key_version: api_key_version,
    cloudwatch_role_arn: cloudwatch_role_arn,
    features: features,
    throttle_settings: throttle_settings,
  ))
}

pub fn decode_account_struct_params() -> decode.Decoder(Account) {
  use <- decode.recursive
  use api_key_version <- decode.optional_field(
    "apiKeyVersion",
    option.None,
    decode.optional(decode.string),
  )
  use cloudwatch_role_arn <- decode.optional_field(
    "cloudwatchRoleArn",
    option.None,
    decode.optional(decode.string),
  )
  use features <- decode.optional_field(
    "features",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  use throttle_settings <- decode.optional_field(
    "throttleSettings",
    option.None,
    decode.optional(decode_throttle_settings_struct_params()),
  )
  decode.success(Account(
    api_key_version: api_key_version,
    cloudwatch_role_arn: cloudwatch_role_arn,
    features: features,
    throttle_settings: throttle_settings,
  ))
}

pub type GetApiKeyRequest {
  GetApiKeyRequest(
    api_key: option.Option(String),
    include_value: option.Option(Bool),
  )
}

pub fn encode_get_api_key_request_struct(input: GetApiKeyRequest) -> json.Json {
  let pairs = []
  let pairs = case input.api_key {
    option.Some(v) -> [#("apiKey", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.include_value {
    option.Some(v) -> [#("includeValue", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_api_key_request_struct() -> decode.Decoder(GetApiKeyRequest) {
  use <- decode.recursive
  use api_key <- decode.optional_field(
    "apiKey",
    option.None,
    decode.optional(decode.string),
  )
  use include_value <- decode.optional_field(
    "includeValue",
    option.None,
    decode.optional(decode.bool),
  )
  decode.success(GetApiKeyRequest(
    api_key: api_key,
    include_value: include_value,
  ))
}

pub fn decode_get_api_key_request_struct_params() -> decode.Decoder(
  GetApiKeyRequest,
) {
  use <- decode.recursive
  use api_key <- decode.optional_field(
    "apiKey",
    option.None,
    decode.optional(decode.string),
  )
  use include_value <- decode.optional_field(
    "includeValue",
    option.None,
    decode.optional(decode.bool),
  )
  decode.success(GetApiKeyRequest(
    api_key: api_key,
    include_value: include_value,
  ))
}

pub type GetApiKeysRequest {
  GetApiKeysRequest(
    customer_id: option.Option(String),
    include_values: option.Option(Bool),
    limit: option.Option(Int),
    name_query: option.Option(String),
    position: option.Option(String),
  )
}

pub fn encode_get_api_keys_request_struct(
  input: GetApiKeysRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.customer_id {
    option.Some(v) -> [#("customerId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.include_values {
    option.Some(v) -> [#("includeValues", 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.name_query {
    option.Some(v) -> [#("nameQuery", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_api_keys_request_struct() -> decode.Decoder(GetApiKeysRequest) {
  use <- decode.recursive
  use customer_id <- decode.optional_field(
    "customerId",
    option.None,
    decode.optional(decode.string),
  )
  use include_values <- decode.optional_field(
    "includeValues",
    option.None,
    decode.optional(decode.bool),
  )
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use name_query <- decode.optional_field(
    "nameQuery",
    option.None,
    decode.optional(decode.string),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetApiKeysRequest(
    customer_id: customer_id,
    include_values: include_values,
    limit: limit,
    name_query: name_query,
    position: position,
  ))
}

pub fn decode_get_api_keys_request_struct_params() -> decode.Decoder(
  GetApiKeysRequest,
) {
  use <- decode.recursive
  use customer_id <- decode.optional_field(
    "customerId",
    option.None,
    decode.optional(decode.string),
  )
  use include_values <- decode.optional_field(
    "includeValues",
    option.None,
    decode.optional(decode.bool),
  )
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use name_query <- decode.optional_field(
    "nameQuery",
    option.None,
    decode.optional(decode.string),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetApiKeysRequest(
    customer_id: customer_id,
    include_values: include_values,
    limit: limit,
    name_query: name_query,
    position: position,
  ))
}

pub type ApiKeys {
  ApiKeys(
    items: option.Option(List(ApiKey)),
    position: option.Option(String),
    warnings: option.Option(List(String)),
  )
}

pub fn encode_api_keys_struct(input: ApiKeys) -> json.Json {
  let pairs = []
  let pairs = case input.items {
    option.Some(v) -> [
      #("item", fn(xs) { json.array(xs, encode_api_key_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.warnings {
    option.Some(v) -> [
      #("warnings", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_api_keys_struct() -> decode.Decoder(ApiKeys) {
  use <- decode.recursive
  use items <- decode.optional_field(
    "item",
    option.None,
    decode.optional(decode.list(decode_api_key_struct())),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  use warnings <- decode.optional_field(
    "warnings",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  decode.success(ApiKeys(items: items, position: position, warnings: warnings))
}

pub fn decode_api_keys_struct_params() -> decode.Decoder(ApiKeys) {
  use <- decode.recursive
  use items <- decode.optional_field(
    "items",
    option.None,
    decode.optional(decode.list(decode_api_key_struct_params())),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  use warnings <- decode.optional_field(
    "warnings",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  decode.success(ApiKeys(items: items, position: position, warnings: warnings))
}

pub type GetAuthorizerRequest {
  GetAuthorizerRequest(
    authorizer_id: option.Option(String),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_get_authorizer_request_struct(
  input: GetAuthorizerRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.authorizer_id {
    option.Some(v) -> [#("authorizerId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_authorizer_request_struct() -> decode.Decoder(
  GetAuthorizerRequest,
) {
  use <- decode.recursive
  use authorizer_id <- decode.optional_field(
    "authorizerId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetAuthorizerRequest(
    authorizer_id: authorizer_id,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_get_authorizer_request_struct_params() -> decode.Decoder(
  GetAuthorizerRequest,
) {
  use <- decode.recursive
  use authorizer_id <- decode.optional_field(
    "authorizerId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetAuthorizerRequest(
    authorizer_id: authorizer_id,
    rest_api_id: rest_api_id,
  ))
}

pub type GetAuthorizersRequest {
  GetAuthorizersRequest(
    limit: option.Option(Int),
    position: option.Option(String),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_get_authorizers_request_struct(
  input: GetAuthorizersRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.limit {
    option.Some(v) -> [#("limit", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_authorizers_request_struct() -> decode.Decoder(
  GetAuthorizersRequest,
) {
  use <- decode.recursive
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetAuthorizersRequest(
    limit: limit,
    position: position,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_get_authorizers_request_struct_params() -> decode.Decoder(
  GetAuthorizersRequest,
) {
  use <- decode.recursive
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetAuthorizersRequest(
    limit: limit,
    position: position,
    rest_api_id: rest_api_id,
  ))
}

pub type Authorizers {
  Authorizers(
    items: option.Option(List(Authorizer)),
    position: option.Option(String),
  )
}

pub fn encode_authorizers_struct(input: Authorizers) -> json.Json {
  let pairs = []
  let pairs = case input.items {
    option.Some(v) -> [
      #("item", fn(xs) { json.array(xs, encode_authorizer_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_authorizers_struct() -> decode.Decoder(Authorizers) {
  use <- decode.recursive
  use items <- decode.optional_field(
    "item",
    option.None,
    decode.optional(decode.list(decode_authorizer_struct())),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(Authorizers(items: items, position: position))
}

pub fn decode_authorizers_struct_params() -> decode.Decoder(Authorizers) {
  use <- decode.recursive
  use items <- decode.optional_field(
    "items",
    option.None,
    decode.optional(decode.list(decode_authorizer_struct_params())),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(Authorizers(items: items, position: position))
}

pub type GetBasePathMappingRequest {
  GetBasePathMappingRequest(
    base_path: option.Option(String),
    domain_name: option.Option(String),
    domain_name_id: option.Option(String),
  )
}

pub fn encode_get_base_path_mapping_request_struct(
  input: GetBasePathMappingRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.base_path {
    option.Some(v) -> [#("basePath", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.domain_name {
    option.Some(v) -> [#("domainName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.domain_name_id {
    option.Some(v) -> [#("domainNameId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_base_path_mapping_request_struct() -> decode.Decoder(
  GetBasePathMappingRequest,
) {
  use <- decode.recursive
  use base_path <- decode.optional_field(
    "basePath",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name <- decode.optional_field(
    "domainName",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name_id <- decode.optional_field(
    "domainNameId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetBasePathMappingRequest(
    base_path: base_path,
    domain_name: domain_name,
    domain_name_id: domain_name_id,
  ))
}

pub fn decode_get_base_path_mapping_request_struct_params() -> decode.Decoder(
  GetBasePathMappingRequest,
) {
  use <- decode.recursive
  use base_path <- decode.optional_field(
    "basePath",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name <- decode.optional_field(
    "domainName",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name_id <- decode.optional_field(
    "domainNameId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetBasePathMappingRequest(
    base_path: base_path,
    domain_name: domain_name,
    domain_name_id: domain_name_id,
  ))
}

pub type GetBasePathMappingsRequest {
  GetBasePathMappingsRequest(
    domain_name: option.Option(String),
    domain_name_id: option.Option(String),
    limit: option.Option(Int),
    position: option.Option(String),
  )
}

pub fn encode_get_base_path_mappings_request_struct(
  input: GetBasePathMappingsRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.domain_name {
    option.Some(v) -> [#("domainName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.domain_name_id {
    option.Some(v) -> [#("domainNameId", 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.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_base_path_mappings_request_struct() -> decode.Decoder(
  GetBasePathMappingsRequest,
) {
  use <- decode.recursive
  use domain_name <- decode.optional_field(
    "domainName",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name_id <- decode.optional_field(
    "domainNameId",
    option.None,
    decode.optional(decode.string),
  )
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetBasePathMappingsRequest(
    domain_name: domain_name,
    domain_name_id: domain_name_id,
    limit: limit,
    position: position,
  ))
}

pub fn decode_get_base_path_mappings_request_struct_params() -> decode.Decoder(
  GetBasePathMappingsRequest,
) {
  use <- decode.recursive
  use domain_name <- decode.optional_field(
    "domainName",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name_id <- decode.optional_field(
    "domainNameId",
    option.None,
    decode.optional(decode.string),
  )
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetBasePathMappingsRequest(
    domain_name: domain_name,
    domain_name_id: domain_name_id,
    limit: limit,
    position: position,
  ))
}

pub type BasePathMappings {
  BasePathMappings(
    items: option.Option(List(BasePathMapping)),
    position: option.Option(String),
  )
}

pub fn encode_base_path_mappings_struct(input: BasePathMappings) -> json.Json {
  let pairs = []
  let pairs = case input.items {
    option.Some(v) -> [
      #("item", fn(xs) { json.array(xs, encode_base_path_mapping_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_base_path_mappings_struct() -> decode.Decoder(BasePathMappings) {
  use <- decode.recursive
  use items <- decode.optional_field(
    "item",
    option.None,
    decode.optional(decode.list(decode_base_path_mapping_struct())),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(BasePathMappings(items: items, position: position))
}

pub fn decode_base_path_mappings_struct_params() -> decode.Decoder(
  BasePathMappings,
) {
  use <- decode.recursive
  use items <- decode.optional_field(
    "items",
    option.None,
    decode.optional(decode.list(decode_base_path_mapping_struct_params())),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(BasePathMappings(items: items, position: position))
}

pub type GetClientCertificateRequest {
  GetClientCertificateRequest(client_certificate_id: option.Option(String))
}

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

pub fn decode_get_client_certificate_request_struct() -> decode.Decoder(
  GetClientCertificateRequest,
) {
  use <- decode.recursive
  use client_certificate_id <- decode.optional_field(
    "clientCertificateId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetClientCertificateRequest(
    client_certificate_id: client_certificate_id,
  ))
}

pub fn decode_get_client_certificate_request_struct_params() -> decode.Decoder(
  GetClientCertificateRequest,
) {
  use <- decode.recursive
  use client_certificate_id <- decode.optional_field(
    "clientCertificateId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetClientCertificateRequest(
    client_certificate_id: client_certificate_id,
  ))
}

pub type GetClientCertificatesRequest {
  GetClientCertificatesRequest(
    limit: option.Option(Int),
    position: option.Option(String),
  )
}

pub fn encode_get_client_certificates_request_struct(
  input: GetClientCertificatesRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.limit {
    option.Some(v) -> [#("limit", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_client_certificates_request_struct() -> decode.Decoder(
  GetClientCertificatesRequest,
) {
  use <- decode.recursive
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetClientCertificatesRequest(limit: limit, position: position))
}

pub fn decode_get_client_certificates_request_struct_params() -> decode.Decoder(
  GetClientCertificatesRequest,
) {
  use <- decode.recursive
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetClientCertificatesRequest(limit: limit, position: position))
}

pub type ClientCertificates {
  ClientCertificates(
    items: option.Option(List(ClientCertificate)),
    position: option.Option(String),
  )
}

pub fn encode_client_certificates_struct(
  input: ClientCertificates,
) -> json.Json {
  let pairs = []
  let pairs = case input.items {
    option.Some(v) -> [
      #("item", fn(xs) { json.array(xs, encode_client_certificate_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_client_certificates_struct() -> decode.Decoder(ClientCertificates) {
  use <- decode.recursive
  use items <- decode.optional_field(
    "item",
    option.None,
    decode.optional(decode.list(decode_client_certificate_struct())),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ClientCertificates(items: items, position: position))
}

pub fn decode_client_certificates_struct_params() -> decode.Decoder(
  ClientCertificates,
) {
  use <- decode.recursive
  use items <- decode.optional_field(
    "items",
    option.None,
    decode.optional(decode.list(decode_client_certificate_struct_params())),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ClientCertificates(items: items, position: position))
}

pub type GetDeploymentRequest {
  GetDeploymentRequest(
    deployment_id: option.Option(String),
    embed: option.Option(List(String)),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_get_deployment_request_struct(
  input: GetDeploymentRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.deployment_id {
    option.Some(v) -> [#("deploymentId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.embed {
    option.Some(v) -> [
      #("embed", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_deployment_request_struct() -> decode.Decoder(
  GetDeploymentRequest,
) {
  use <- decode.recursive
  use deployment_id <- decode.optional_field(
    "deploymentId",
    option.None,
    decode.optional(decode.string),
  )
  use embed <- decode.optional_field(
    "embed",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetDeploymentRequest(
    deployment_id: deployment_id,
    embed: embed,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_get_deployment_request_struct_params() -> decode.Decoder(
  GetDeploymentRequest,
) {
  use <- decode.recursive
  use deployment_id <- decode.optional_field(
    "deploymentId",
    option.None,
    decode.optional(decode.string),
  )
  use embed <- decode.optional_field(
    "embed",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetDeploymentRequest(
    deployment_id: deployment_id,
    embed: embed,
    rest_api_id: rest_api_id,
  ))
}

pub type GetDeploymentsRequest {
  GetDeploymentsRequest(
    limit: option.Option(Int),
    position: option.Option(String),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_get_deployments_request_struct(
  input: GetDeploymentsRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.limit {
    option.Some(v) -> [#("limit", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_deployments_request_struct() -> decode.Decoder(
  GetDeploymentsRequest,
) {
  use <- decode.recursive
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetDeploymentsRequest(
    limit: limit,
    position: position,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_get_deployments_request_struct_params() -> decode.Decoder(
  GetDeploymentsRequest,
) {
  use <- decode.recursive
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetDeploymentsRequest(
    limit: limit,
    position: position,
    rest_api_id: rest_api_id,
  ))
}

pub type Deployments {
  Deployments(
    items: option.Option(List(Deployment)),
    position: option.Option(String),
  )
}

pub fn encode_deployments_struct(input: Deployments) -> json.Json {
  let pairs = []
  let pairs = case input.items {
    option.Some(v) -> [
      #("item", fn(xs) { json.array(xs, encode_deployment_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_deployments_struct() -> decode.Decoder(Deployments) {
  use <- decode.recursive
  use items <- decode.optional_field(
    "item",
    option.None,
    decode.optional(decode.list(decode_deployment_struct())),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(Deployments(items: items, position: position))
}

pub fn decode_deployments_struct_params() -> decode.Decoder(Deployments) {
  use <- decode.recursive
  use items <- decode.optional_field(
    "items",
    option.None,
    decode.optional(decode.list(decode_deployment_struct_params())),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(Deployments(items: items, position: position))
}

pub type GetDocumentationPartRequest {
  GetDocumentationPartRequest(
    documentation_part_id: option.Option(String),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_get_documentation_part_request_struct(
  input: GetDocumentationPartRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.documentation_part_id {
    option.Some(v) -> [#("documentationPartId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_documentation_part_request_struct() -> decode.Decoder(
  GetDocumentationPartRequest,
) {
  use <- decode.recursive
  use documentation_part_id <- decode.optional_field(
    "documentationPartId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetDocumentationPartRequest(
    documentation_part_id: documentation_part_id,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_get_documentation_part_request_struct_params() -> decode.Decoder(
  GetDocumentationPartRequest,
) {
  use <- decode.recursive
  use documentation_part_id <- decode.optional_field(
    "documentationPartId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetDocumentationPartRequest(
    documentation_part_id: documentation_part_id,
    rest_api_id: rest_api_id,
  ))
}

pub type GetDocumentationPartsRequest {
  GetDocumentationPartsRequest(
    limit: option.Option(Int),
    location_status: option.Option(LocationStatusType),
    name_query: option.Option(String),
    path: option.Option(String),
    position: option.Option(String),
    rest_api_id: option.Option(String),
    type_: option.Option(DocumentationPartType),
  )
}

pub fn encode_get_documentation_parts_request_struct(
  input: GetDocumentationPartsRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.limit {
    option.Some(v) -> [#("limit", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.location_status {
    option.Some(v) -> [
      #("locationStatus", encode_location_status_type_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.name_query {
    option.Some(v) -> [#("nameQuery", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.path {
    option.Some(v) -> [#("path", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.type_ {
    option.Some(v) -> [
      #("type", encode_documentation_part_type_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_documentation_parts_request_struct() -> decode.Decoder(
  GetDocumentationPartsRequest,
) {
  use <- decode.recursive
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use location_status <- decode.optional_field(
    "locationStatus",
    option.None,
    decode.optional(decode_location_status_type_enum()),
  )
  use name_query <- decode.optional_field(
    "nameQuery",
    option.None,
    decode.optional(decode.string),
  )
  use path <- decode.optional_field(
    "path",
    option.None,
    decode.optional(decode.string),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use type_ <- decode.optional_field(
    "type",
    option.None,
    decode.optional(decode_documentation_part_type_enum()),
  )
  decode.success(GetDocumentationPartsRequest(
    limit: limit,
    location_status: location_status,
    name_query: name_query,
    path: path,
    position: position,
    rest_api_id: rest_api_id,
    type_: type_,
  ))
}

pub fn decode_get_documentation_parts_request_struct_params() -> decode.Decoder(
  GetDocumentationPartsRequest,
) {
  use <- decode.recursive
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use location_status <- decode.optional_field(
    "locationStatus",
    option.None,
    decode.optional(decode_location_status_type_enum()),
  )
  use name_query <- decode.optional_field(
    "nameQuery",
    option.None,
    decode.optional(decode.string),
  )
  use path <- decode.optional_field(
    "path",
    option.None,
    decode.optional(decode.string),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use type_ <- decode.optional_field(
    "type",
    option.None,
    decode.optional(decode_documentation_part_type_enum()),
  )
  decode.success(GetDocumentationPartsRequest(
    limit: limit,
    location_status: location_status,
    name_query: name_query,
    path: path,
    position: position,
    rest_api_id: rest_api_id,
    type_: type_,
  ))
}

pub type LocationStatusType {
  LocationStatusTypeDocumented
  LocationStatusTypeUndocumented
}

pub fn encode_location_status_type_enum(v: LocationStatusType) -> json.Json {
  case v {
    LocationStatusTypeDocumented -> json.string("DOCUMENTED")
    LocationStatusTypeUndocumented -> json.string("UNDOCUMENTED")
  }
}

pub fn decode_location_status_type_enum() -> decode.Decoder(LocationStatusType) {
  decode.then(decode.string, fn(s) {
    case s {
      "DOCUMENTED" -> decode.success(LocationStatusTypeDocumented)
      "UNDOCUMENTED" -> decode.success(LocationStatusTypeUndocumented)
      _ -> decode.failure(LocationStatusTypeDocumented, "unknown enum value")
    }
  })
}

pub fn location_status_type_from_wire(
  s: String,
) -> Result(LocationStatusType, String) {
  case s {
    "DOCUMENTED" -> Ok(LocationStatusTypeDocumented)
    "UNDOCUMENTED" -> Ok(LocationStatusTypeUndocumented)
    _ -> Ok(LocationStatusTypeDocumented)
  }
}

pub type DocumentationParts {
  DocumentationParts(
    items: option.Option(List(DocumentationPart)),
    position: option.Option(String),
  )
}

pub fn encode_documentation_parts_struct(
  input: DocumentationParts,
) -> json.Json {
  let pairs = []
  let pairs = case input.items {
    option.Some(v) -> [
      #("item", fn(xs) { json.array(xs, encode_documentation_part_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_documentation_parts_struct() -> decode.Decoder(DocumentationParts) {
  use <- decode.recursive
  use items <- decode.optional_field(
    "item",
    option.None,
    decode.optional(decode.list(decode_documentation_part_struct())),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DocumentationParts(items: items, position: position))
}

pub fn decode_documentation_parts_struct_params() -> decode.Decoder(
  DocumentationParts,
) {
  use <- decode.recursive
  use items <- decode.optional_field(
    "items",
    option.None,
    decode.optional(decode.list(decode_documentation_part_struct_params())),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DocumentationParts(items: items, position: position))
}

pub type GetDocumentationVersionRequest {
  GetDocumentationVersionRequest(
    documentation_version: option.Option(String),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_get_documentation_version_request_struct(
  input: GetDocumentationVersionRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.documentation_version {
    option.Some(v) -> [#("documentationVersion", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_documentation_version_request_struct() -> decode.Decoder(
  GetDocumentationVersionRequest,
) {
  use <- decode.recursive
  use documentation_version <- decode.optional_field(
    "documentationVersion",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetDocumentationVersionRequest(
    documentation_version: documentation_version,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_get_documentation_version_request_struct_params() -> decode.Decoder(
  GetDocumentationVersionRequest,
) {
  use <- decode.recursive
  use documentation_version <- decode.optional_field(
    "documentationVersion",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetDocumentationVersionRequest(
    documentation_version: documentation_version,
    rest_api_id: rest_api_id,
  ))
}

pub type GetDocumentationVersionsRequest {
  GetDocumentationVersionsRequest(
    limit: option.Option(Int),
    position: option.Option(String),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_get_documentation_versions_request_struct(
  input: GetDocumentationVersionsRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.limit {
    option.Some(v) -> [#("limit", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_documentation_versions_request_struct() -> decode.Decoder(
  GetDocumentationVersionsRequest,
) {
  use <- decode.recursive
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetDocumentationVersionsRequest(
    limit: limit,
    position: position,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_get_documentation_versions_request_struct_params() -> decode.Decoder(
  GetDocumentationVersionsRequest,
) {
  use <- decode.recursive
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetDocumentationVersionsRequest(
    limit: limit,
    position: position,
    rest_api_id: rest_api_id,
  ))
}

pub type DocumentationVersions {
  DocumentationVersions(
    items: option.Option(List(DocumentationVersion)),
    position: option.Option(String),
  )
}

pub fn encode_documentation_versions_struct(
  input: DocumentationVersions,
) -> json.Json {
  let pairs = []
  let pairs = case input.items {
    option.Some(v) -> [
      #(
        "item",
        fn(xs) { json.array(xs, encode_documentation_version_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_documentation_versions_struct() -> decode.Decoder(
  DocumentationVersions,
) {
  use <- decode.recursive
  use items <- decode.optional_field(
    "item",
    option.None,
    decode.optional(decode.list(decode_documentation_version_struct())),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DocumentationVersions(items: items, position: position))
}

pub fn decode_documentation_versions_struct_params() -> decode.Decoder(
  DocumentationVersions,
) {
  use <- decode.recursive
  use items <- decode.optional_field(
    "items",
    option.None,
    decode.optional(decode.list(decode_documentation_version_struct_params())),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DocumentationVersions(items: items, position: position))
}

pub type GetDomainNameRequest {
  GetDomainNameRequest(
    domain_name: option.Option(String),
    domain_name_id: option.Option(String),
  )
}

pub fn encode_get_domain_name_request_struct(
  input: GetDomainNameRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.domain_name {
    option.Some(v) -> [#("domainName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.domain_name_id {
    option.Some(v) -> [#("domainNameId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_domain_name_request_struct() -> decode.Decoder(
  GetDomainNameRequest,
) {
  use <- decode.recursive
  use domain_name <- decode.optional_field(
    "domainName",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name_id <- decode.optional_field(
    "domainNameId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetDomainNameRequest(
    domain_name: domain_name,
    domain_name_id: domain_name_id,
  ))
}

pub fn decode_get_domain_name_request_struct_params() -> decode.Decoder(
  GetDomainNameRequest,
) {
  use <- decode.recursive
  use domain_name <- decode.optional_field(
    "domainName",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name_id <- decode.optional_field(
    "domainNameId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetDomainNameRequest(
    domain_name: domain_name,
    domain_name_id: domain_name_id,
  ))
}

pub type GetDomainNameAccessAssociationsRequest {
  GetDomainNameAccessAssociationsRequest(
    limit: option.Option(Int),
    position: option.Option(String),
    resource_owner: option.Option(ResourceOwner),
  )
}

pub fn encode_get_domain_name_access_associations_request_struct(
  input: GetDomainNameAccessAssociationsRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.limit {
    option.Some(v) -> [#("limit", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.resource_owner {
    option.Some(v) -> [
      #("resourceOwner", encode_resource_owner_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_domain_name_access_associations_request_struct() -> decode.Decoder(
  GetDomainNameAccessAssociationsRequest,
) {
  use <- decode.recursive
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  use resource_owner <- decode.optional_field(
    "resourceOwner",
    option.None,
    decode.optional(decode_resource_owner_enum()),
  )
  decode.success(GetDomainNameAccessAssociationsRequest(
    limit: limit,
    position: position,
    resource_owner: resource_owner,
  ))
}

pub fn decode_get_domain_name_access_associations_request_struct_params() -> decode.Decoder(
  GetDomainNameAccessAssociationsRequest,
) {
  use <- decode.recursive
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  use resource_owner <- decode.optional_field(
    "resourceOwner",
    option.None,
    decode.optional(decode_resource_owner_enum()),
  )
  decode.success(GetDomainNameAccessAssociationsRequest(
    limit: limit,
    position: position,
    resource_owner: resource_owner,
  ))
}

pub type ResourceOwner {
  ResourceOwnerOtherAccounts
  ResourceOwnerSelf
}

pub fn encode_resource_owner_enum(v: ResourceOwner) -> json.Json {
  case v {
    ResourceOwnerOtherAccounts -> json.string("OTHER_ACCOUNTS")
    ResourceOwnerSelf -> json.string("SELF")
  }
}

pub fn decode_resource_owner_enum() -> decode.Decoder(ResourceOwner) {
  decode.then(decode.string, fn(s) {
    case s {
      "OTHER_ACCOUNTS" -> decode.success(ResourceOwnerOtherAccounts)
      "SELF" -> decode.success(ResourceOwnerSelf)
      _ -> decode.failure(ResourceOwnerOtherAccounts, "unknown enum value")
    }
  })
}

pub fn resource_owner_from_wire(s: String) -> Result(ResourceOwner, String) {
  case s {
    "OTHER_ACCOUNTS" -> Ok(ResourceOwnerOtherAccounts)
    "SELF" -> Ok(ResourceOwnerSelf)
    _ -> Ok(ResourceOwnerOtherAccounts)
  }
}

pub type DomainNameAccessAssociations {
  DomainNameAccessAssociations(
    items: option.Option(List(DomainNameAccessAssociation)),
    position: option.Option(String),
  )
}

pub fn encode_domain_name_access_associations_struct(
  input: DomainNameAccessAssociations,
) -> json.Json {
  let pairs = []
  let pairs = case input.items {
    option.Some(v) -> [
      #(
        "item",
        fn(xs) { json.array(xs, encode_domain_name_access_association_struct) }(
          v,
        ),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_domain_name_access_associations_struct() -> decode.Decoder(
  DomainNameAccessAssociations,
) {
  use <- decode.recursive
  use items <- decode.optional_field(
    "item",
    option.None,
    decode.optional(decode.list(decode_domain_name_access_association_struct())),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DomainNameAccessAssociations(items: items, position: position))
}

pub fn decode_domain_name_access_associations_struct_params() -> decode.Decoder(
  DomainNameAccessAssociations,
) {
  use <- decode.recursive
  use items <- decode.optional_field(
    "items",
    option.None,
    decode.optional(
      decode.list(decode_domain_name_access_association_struct_params()),
    ),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DomainNameAccessAssociations(items: items, position: position))
}

pub type GetDomainNamesRequest {
  GetDomainNamesRequest(
    limit: option.Option(Int),
    position: option.Option(String),
    resource_owner: option.Option(ResourceOwner),
  )
}

pub fn encode_get_domain_names_request_struct(
  input: GetDomainNamesRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.limit {
    option.Some(v) -> [#("limit", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.resource_owner {
    option.Some(v) -> [
      #("resourceOwner", encode_resource_owner_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_domain_names_request_struct() -> decode.Decoder(
  GetDomainNamesRequest,
) {
  use <- decode.recursive
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  use resource_owner <- decode.optional_field(
    "resourceOwner",
    option.None,
    decode.optional(decode_resource_owner_enum()),
  )
  decode.success(GetDomainNamesRequest(
    limit: limit,
    position: position,
    resource_owner: resource_owner,
  ))
}

pub fn decode_get_domain_names_request_struct_params() -> decode.Decoder(
  GetDomainNamesRequest,
) {
  use <- decode.recursive
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  use resource_owner <- decode.optional_field(
    "resourceOwner",
    option.None,
    decode.optional(decode_resource_owner_enum()),
  )
  decode.success(GetDomainNamesRequest(
    limit: limit,
    position: position,
    resource_owner: resource_owner,
  ))
}

pub type DomainNames {
  DomainNames(
    items: option.Option(List(DomainName)),
    position: option.Option(String),
  )
}

pub fn encode_domain_names_struct(input: DomainNames) -> json.Json {
  let pairs = []
  let pairs = case input.items {
    option.Some(v) -> [
      #("item", fn(xs) { json.array(xs, encode_domain_name_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_domain_names_struct() -> decode.Decoder(DomainNames) {
  use <- decode.recursive
  use items <- decode.optional_field(
    "item",
    option.None,
    decode.optional(decode.list(decode_domain_name_struct())),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DomainNames(items: items, position: position))
}

pub fn decode_domain_names_struct_params() -> decode.Decoder(DomainNames) {
  use <- decode.recursive
  use items <- decode.optional_field(
    "items",
    option.None,
    decode.optional(decode.list(decode_domain_name_struct_params())),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(DomainNames(items: items, position: position))
}

pub type GetExportRequest {
  GetExportRequest(
    accepts: option.Option(String),
    export_type: option.Option(String),
    parameters: option.Option(dict.Dict(String, String)),
    rest_api_id: option.Option(String),
    stage_name: option.Option(String),
  )
}

pub fn encode_get_export_request_struct(input: GetExportRequest) -> json.Json {
  let pairs = []
  let pairs = case input.accepts {
    option.Some(v) -> [#("accepts", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.export_type {
    option.Some(v) -> [#("exportType", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.parameters {
    option.Some(v) -> [
      #(
        "parameters",
        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.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.stage_name {
    option.Some(v) -> [#("stageName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_export_request_struct() -> decode.Decoder(GetExportRequest) {
  use <- decode.recursive
  use accepts <- decode.optional_field(
    "accepts",
    option.None,
    decode.optional(decode.string),
  )
  use export_type <- decode.optional_field(
    "exportType",
    option.None,
    decode.optional(decode.string),
  )
  use parameters <- decode.optional_field(
    "parameters",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use stage_name <- decode.optional_field(
    "stageName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetExportRequest(
    accepts: accepts,
    export_type: export_type,
    parameters: parameters,
    rest_api_id: rest_api_id,
    stage_name: stage_name,
  ))
}

pub fn decode_get_export_request_struct_params() -> decode.Decoder(
  GetExportRequest,
) {
  use <- decode.recursive
  use accepts <- decode.optional_field(
    "accepts",
    option.None,
    decode.optional(decode.string),
  )
  use export_type <- decode.optional_field(
    "exportType",
    option.None,
    decode.optional(decode.string),
  )
  use parameters <- decode.optional_field(
    "parameters",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use stage_name <- decode.optional_field(
    "stageName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetExportRequest(
    accepts: accepts,
    export_type: export_type,
    parameters: parameters,
    rest_api_id: rest_api_id,
    stage_name: stage_name,
  ))
}

pub type ExportResponse {
  ExportResponse(
    body: option.Option(BitArray),
    content_disposition: option.Option(String),
    content_type: option.Option(String),
  )
}

pub fn encode_export_response_struct(input: ExportResponse) -> json.Json {
  let pairs = []
  let pairs = case input.body {
    option.Some(v) -> [
      #("body", fn(b) { json.string(bit_array.base64_encode(b, True)) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.content_disposition {
    option.Some(v) -> [#("contentDisposition", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.content_type {
    option.Some(v) -> [#("contentType", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_export_response_struct() -> decode.Decoder(ExportResponse) {
  use <- decode.recursive
  use body <- decode.optional_field(
    "body",
    option.None,
    decode.optional(
      decode.then(decode.string, fn(s) {
        decode.success(bit_array.from_string(s))
      }),
    ),
  )
  use content_disposition <- decode.optional_field(
    "contentDisposition",
    option.None,
    decode.optional(decode.string),
  )
  use content_type <- decode.optional_field(
    "contentType",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ExportResponse(
    body: body,
    content_disposition: content_disposition,
    content_type: content_type,
  ))
}

pub fn decode_export_response_struct_params() -> decode.Decoder(ExportResponse) {
  use <- decode.recursive
  use body <- decode.optional_field(
    "body",
    option.None,
    decode.optional(
      decode.then(decode.string, fn(s) {
        decode.success(bit_array.from_string(s))
      }),
    ),
  )
  use content_disposition <- decode.optional_field(
    "contentDisposition",
    option.None,
    decode.optional(decode.string),
  )
  use content_type <- decode.optional_field(
    "contentType",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ExportResponse(
    body: body,
    content_disposition: content_disposition,
    content_type: content_type,
  ))
}

pub type GetGatewayResponseRequest {
  GetGatewayResponseRequest(
    response_type: option.Option(GatewayResponseType),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_get_gateway_response_request_struct(
  input: GetGatewayResponseRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.response_type {
    option.Some(v) -> [
      #("responseType", encode_gateway_response_type_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_gateway_response_request_struct() -> decode.Decoder(
  GetGatewayResponseRequest,
) {
  use <- decode.recursive
  use response_type <- decode.optional_field(
    "responseType",
    option.None,
    decode.optional(decode_gateway_response_type_enum()),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetGatewayResponseRequest(
    response_type: response_type,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_get_gateway_response_request_struct_params() -> decode.Decoder(
  GetGatewayResponseRequest,
) {
  use <- decode.recursive
  use response_type <- decode.optional_field(
    "responseType",
    option.None,
    decode.optional(decode_gateway_response_type_enum()),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetGatewayResponseRequest(
    response_type: response_type,
    rest_api_id: rest_api_id,
  ))
}

pub type GatewayResponse {
  GatewayResponse(
    default_response: option.Option(Bool),
    response_parameters: option.Option(dict.Dict(String, String)),
    response_templates: option.Option(dict.Dict(String, String)),
    response_type: option.Option(GatewayResponseType),
    status_code: option.Option(String),
  )
}

pub fn encode_gateway_response_struct(input: GatewayResponse) -> json.Json {
  let pairs = []
  let pairs = case input.default_response {
    option.Some(v) -> [#("defaultResponse", json.bool(v)), ..pairs]
    option.None -> [#("defaultResponse", json.bool(False)), ..pairs]
  }
  let pairs = case input.response_parameters {
    option.Some(v) -> [
      #(
        "responseParameters",
        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.response_templates {
    option.Some(v) -> [
      #(
        "responseTemplates",
        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.response_type {
    option.Some(v) -> [
      #("responseType", encode_gateway_response_type_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.status_code {
    option.Some(v) -> [#("statusCode", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_gateway_response_struct() -> decode.Decoder(GatewayResponse) {
  use <- decode.recursive
  use default_response <- decode.optional_field(
    "defaultResponse",
    option.None,
    decode.optional(decode.bool),
  )
  use response_parameters <- decode.optional_field(
    "responseParameters",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use response_templates <- decode.optional_field(
    "responseTemplates",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use response_type <- decode.optional_field(
    "responseType",
    option.None,
    decode.optional(decode_gateway_response_type_enum()),
  )
  use status_code <- decode.optional_field(
    "statusCode",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GatewayResponse(
    default_response: default_response,
    response_parameters: response_parameters,
    response_templates: response_templates,
    response_type: response_type,
    status_code: status_code,
  ))
}

pub fn decode_gateway_response_struct_params() -> decode.Decoder(
  GatewayResponse,
) {
  use <- decode.recursive
  use default_response <- decode.optional_field(
    "defaultResponse",
    option.None,
    decode.optional(decode.bool),
  )
  use response_parameters <- decode.optional_field(
    "responseParameters",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use response_templates <- decode.optional_field(
    "responseTemplates",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use response_type <- decode.optional_field(
    "responseType",
    option.None,
    decode.optional(decode_gateway_response_type_enum()),
  )
  use status_code <- decode.optional_field(
    "statusCode",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GatewayResponse(
    default_response: default_response,
    response_parameters: response_parameters,
    response_templates: response_templates,
    response_type: response_type,
    status_code: status_code,
  ))
}

pub type GetGatewayResponsesRequest {
  GetGatewayResponsesRequest(
    limit: option.Option(Int),
    position: option.Option(String),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_get_gateway_responses_request_struct(
  input: GetGatewayResponsesRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.limit {
    option.Some(v) -> [#("limit", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_gateway_responses_request_struct() -> decode.Decoder(
  GetGatewayResponsesRequest,
) {
  use <- decode.recursive
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetGatewayResponsesRequest(
    limit: limit,
    position: position,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_get_gateway_responses_request_struct_params() -> decode.Decoder(
  GetGatewayResponsesRequest,
) {
  use <- decode.recursive
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetGatewayResponsesRequest(
    limit: limit,
    position: position,
    rest_api_id: rest_api_id,
  ))
}

pub type GatewayResponses {
  GatewayResponses(
    items: option.Option(List(GatewayResponse)),
    position: option.Option(String),
  )
}

pub fn encode_gateway_responses_struct(input: GatewayResponses) -> json.Json {
  let pairs = []
  let pairs = case input.items {
    option.Some(v) -> [
      #("item", fn(xs) { json.array(xs, encode_gateway_response_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_gateway_responses_struct() -> decode.Decoder(GatewayResponses) {
  use <- decode.recursive
  use items <- decode.optional_field(
    "item",
    option.None,
    decode.optional(decode.list(decode_gateway_response_struct())),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GatewayResponses(items: items, position: position))
}

pub fn decode_gateway_responses_struct_params() -> decode.Decoder(
  GatewayResponses,
) {
  use <- decode.recursive
  use items <- decode.optional_field(
    "items",
    option.None,
    decode.optional(decode.list(decode_gateway_response_struct_params())),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GatewayResponses(items: items, position: position))
}

pub type GetIntegrationRequest {
  GetIntegrationRequest(
    http_method: option.Option(String),
    resource_id: option.Option(String),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_get_integration_request_struct(
  input: GetIntegrationRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.http_method {
    option.Some(v) -> [#("httpMethod", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.resource_id {
    option.Some(v) -> [#("resourceId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_integration_request_struct() -> decode.Decoder(
  GetIntegrationRequest,
) {
  use <- decode.recursive
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetIntegrationRequest(
    http_method: http_method,
    resource_id: resource_id,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_get_integration_request_struct_params() -> decode.Decoder(
  GetIntegrationRequest,
) {
  use <- decode.recursive
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetIntegrationRequest(
    http_method: http_method,
    resource_id: resource_id,
    rest_api_id: rest_api_id,
  ))
}

pub type GetIntegrationResponseRequest {
  GetIntegrationResponseRequest(
    http_method: option.Option(String),
    resource_id: option.Option(String),
    rest_api_id: option.Option(String),
    status_code: option.Option(String),
  )
}

pub fn encode_get_integration_response_request_struct(
  input: GetIntegrationResponseRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.http_method {
    option.Some(v) -> [#("httpMethod", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.resource_id {
    option.Some(v) -> [#("resourceId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.status_code {
    option.Some(v) -> [#("statusCode", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_integration_response_request_struct() -> decode.Decoder(
  GetIntegrationResponseRequest,
) {
  use <- decode.recursive
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use status_code <- decode.optional_field(
    "statusCode",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetIntegrationResponseRequest(
    http_method: http_method,
    resource_id: resource_id,
    rest_api_id: rest_api_id,
    status_code: status_code,
  ))
}

pub fn decode_get_integration_response_request_struct_params() -> decode.Decoder(
  GetIntegrationResponseRequest,
) {
  use <- decode.recursive
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use status_code <- decode.optional_field(
    "statusCode",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetIntegrationResponseRequest(
    http_method: http_method,
    resource_id: resource_id,
    rest_api_id: rest_api_id,
    status_code: status_code,
  ))
}

pub type GetMethodRequest {
  GetMethodRequest(
    http_method: option.Option(String),
    resource_id: option.Option(String),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_get_method_request_struct(input: GetMethodRequest) -> json.Json {
  let pairs = []
  let pairs = case input.http_method {
    option.Some(v) -> [#("httpMethod", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.resource_id {
    option.Some(v) -> [#("resourceId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_method_request_struct() -> decode.Decoder(GetMethodRequest) {
  use <- decode.recursive
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetMethodRequest(
    http_method: http_method,
    resource_id: resource_id,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_get_method_request_struct_params() -> decode.Decoder(
  GetMethodRequest,
) {
  use <- decode.recursive
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetMethodRequest(
    http_method: http_method,
    resource_id: resource_id,
    rest_api_id: rest_api_id,
  ))
}

pub type GetMethodResponseRequest {
  GetMethodResponseRequest(
    http_method: option.Option(String),
    resource_id: option.Option(String),
    rest_api_id: option.Option(String),
    status_code: option.Option(String),
  )
}

pub fn encode_get_method_response_request_struct(
  input: GetMethodResponseRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.http_method {
    option.Some(v) -> [#("httpMethod", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.resource_id {
    option.Some(v) -> [#("resourceId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.status_code {
    option.Some(v) -> [#("statusCode", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_method_response_request_struct() -> decode.Decoder(
  GetMethodResponseRequest,
) {
  use <- decode.recursive
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use status_code <- decode.optional_field(
    "statusCode",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetMethodResponseRequest(
    http_method: http_method,
    resource_id: resource_id,
    rest_api_id: rest_api_id,
    status_code: status_code,
  ))
}

pub fn decode_get_method_response_request_struct_params() -> decode.Decoder(
  GetMethodResponseRequest,
) {
  use <- decode.recursive
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use status_code <- decode.optional_field(
    "statusCode",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetMethodResponseRequest(
    http_method: http_method,
    resource_id: resource_id,
    rest_api_id: rest_api_id,
    status_code: status_code,
  ))
}

pub type GetModelRequest {
  GetModelRequest(
    flatten: option.Option(Bool),
    model_name: option.Option(String),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_get_model_request_struct(input: GetModelRequest) -> json.Json {
  let pairs = []
  let pairs = case input.flatten {
    option.Some(v) -> [#("flatten", json.bool(v)), ..pairs]
    option.None -> [#("flatten", json.bool(False)), ..pairs]
  }
  let pairs = case input.model_name {
    option.Some(v) -> [#("modelName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_model_request_struct() -> decode.Decoder(GetModelRequest) {
  use <- decode.recursive
  use flatten <- decode.optional_field(
    "flatten",
    option.None,
    decode.optional(decode.bool),
  )
  use model_name <- decode.optional_field(
    "modelName",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetModelRequest(
    flatten: flatten,
    model_name: model_name,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_get_model_request_struct_params() -> decode.Decoder(
  GetModelRequest,
) {
  use <- decode.recursive
  use flatten <- decode.optional_field(
    "flatten",
    option.None,
    decode.optional(decode.bool),
  )
  use model_name <- decode.optional_field(
    "modelName",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetModelRequest(
    flatten: flatten,
    model_name: model_name,
    rest_api_id: rest_api_id,
  ))
}

pub type GetModelsRequest {
  GetModelsRequest(
    limit: option.Option(Int),
    position: option.Option(String),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_get_models_request_struct(input: GetModelsRequest) -> json.Json {
  let pairs = []
  let pairs = case input.limit {
    option.Some(v) -> [#("limit", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_models_request_struct() -> decode.Decoder(GetModelsRequest) {
  use <- decode.recursive
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetModelsRequest(
    limit: limit,
    position: position,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_get_models_request_struct_params() -> decode.Decoder(
  GetModelsRequest,
) {
  use <- decode.recursive
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetModelsRequest(
    limit: limit,
    position: position,
    rest_api_id: rest_api_id,
  ))
}

pub type Models {
  Models(items: option.Option(List(Model)), position: option.Option(String))
}

pub fn encode_models_struct(input: Models) -> json.Json {
  let pairs = []
  let pairs = case input.items {
    option.Some(v) -> [
      #("item", fn(xs) { json.array(xs, encode_model_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_models_struct() -> decode.Decoder(Models) {
  use <- decode.recursive
  use items <- decode.optional_field(
    "item",
    option.None,
    decode.optional(decode.list(decode_model_struct())),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(Models(items: items, position: position))
}

pub fn decode_models_struct_params() -> decode.Decoder(Models) {
  use <- decode.recursive
  use items <- decode.optional_field(
    "items",
    option.None,
    decode.optional(decode.list(decode_model_struct_params())),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(Models(items: items, position: position))
}

pub type GetModelTemplateRequest {
  GetModelTemplateRequest(
    model_name: option.Option(String),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_get_model_template_request_struct(
  input: GetModelTemplateRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.model_name {
    option.Some(v) -> [#("modelName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_model_template_request_struct() -> decode.Decoder(
  GetModelTemplateRequest,
) {
  use <- decode.recursive
  use model_name <- decode.optional_field(
    "modelName",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetModelTemplateRequest(
    model_name: model_name,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_get_model_template_request_struct_params() -> decode.Decoder(
  GetModelTemplateRequest,
) {
  use <- decode.recursive
  use model_name <- decode.optional_field(
    "modelName",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetModelTemplateRequest(
    model_name: model_name,
    rest_api_id: rest_api_id,
  ))
}

pub type Template {
  Template(value: option.Option(String))
}

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

pub fn decode_template_struct() -> decode.Decoder(Template) {
  use <- decode.recursive
  use value <- decode.optional_field(
    "value",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(Template(value: value))
}

pub fn decode_template_struct_params() -> decode.Decoder(Template) {
  use <- decode.recursive
  use value <- decode.optional_field(
    "value",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(Template(value: value))
}

pub type GetRequestValidatorRequest {
  GetRequestValidatorRequest(
    request_validator_id: option.Option(String),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_get_request_validator_request_struct(
  input: GetRequestValidatorRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.request_validator_id {
    option.Some(v) -> [#("requestValidatorId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_request_validator_request_struct() -> decode.Decoder(
  GetRequestValidatorRequest,
) {
  use <- decode.recursive
  use request_validator_id <- decode.optional_field(
    "requestValidatorId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetRequestValidatorRequest(
    request_validator_id: request_validator_id,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_get_request_validator_request_struct_params() -> decode.Decoder(
  GetRequestValidatorRequest,
) {
  use <- decode.recursive
  use request_validator_id <- decode.optional_field(
    "requestValidatorId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetRequestValidatorRequest(
    request_validator_id: request_validator_id,
    rest_api_id: rest_api_id,
  ))
}

pub type GetRequestValidatorsRequest {
  GetRequestValidatorsRequest(
    limit: option.Option(Int),
    position: option.Option(String),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_get_request_validators_request_struct(
  input: GetRequestValidatorsRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.limit {
    option.Some(v) -> [#("limit", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_request_validators_request_struct() -> decode.Decoder(
  GetRequestValidatorsRequest,
) {
  use <- decode.recursive
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetRequestValidatorsRequest(
    limit: limit,
    position: position,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_get_request_validators_request_struct_params() -> decode.Decoder(
  GetRequestValidatorsRequest,
) {
  use <- decode.recursive
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetRequestValidatorsRequest(
    limit: limit,
    position: position,
    rest_api_id: rest_api_id,
  ))
}

pub type RequestValidators {
  RequestValidators(
    items: option.Option(List(RequestValidator)),
    position: option.Option(String),
  )
}

pub fn encode_request_validators_struct(input: RequestValidators) -> json.Json {
  let pairs = []
  let pairs = case input.items {
    option.Some(v) -> [
      #("item", fn(xs) { json.array(xs, encode_request_validator_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_request_validators_struct() -> decode.Decoder(RequestValidators) {
  use <- decode.recursive
  use items <- decode.optional_field(
    "item",
    option.None,
    decode.optional(decode.list(decode_request_validator_struct())),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(RequestValidators(items: items, position: position))
}

pub fn decode_request_validators_struct_params() -> decode.Decoder(
  RequestValidators,
) {
  use <- decode.recursive
  use items <- decode.optional_field(
    "items",
    option.None,
    decode.optional(decode.list(decode_request_validator_struct_params())),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(RequestValidators(items: items, position: position))
}

pub type GetResourceRequest {
  GetResourceRequest(
    embed: option.Option(List(String)),
    resource_id: option.Option(String),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_get_resource_request_struct(
  input: GetResourceRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.embed {
    option.Some(v) -> [
      #("embed", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.resource_id {
    option.Some(v) -> [#("resourceId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_resource_request_struct() -> decode.Decoder(
  GetResourceRequest,
) {
  use <- decode.recursive
  use embed <- decode.optional_field(
    "embed",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetResourceRequest(
    embed: embed,
    resource_id: resource_id,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_get_resource_request_struct_params() -> decode.Decoder(
  GetResourceRequest,
) {
  use <- decode.recursive
  use embed <- decode.optional_field(
    "embed",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetResourceRequest(
    embed: embed,
    resource_id: resource_id,
    rest_api_id: rest_api_id,
  ))
}

pub type GetResourcesRequest {
  GetResourcesRequest(
    embed: option.Option(List(String)),
    limit: option.Option(Int),
    position: option.Option(String),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_get_resources_request_struct(
  input: GetResourcesRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.embed {
    option.Some(v) -> [
      #("embed", fn(xs) { json.array(xs, 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.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_resources_request_struct() -> decode.Decoder(
  GetResourcesRequest,
) {
  use <- decode.recursive
  use embed <- decode.optional_field(
    "embed",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetResourcesRequest(
    embed: embed,
    limit: limit,
    position: position,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_get_resources_request_struct_params() -> decode.Decoder(
  GetResourcesRequest,
) {
  use <- decode.recursive
  use embed <- decode.optional_field(
    "embed",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetResourcesRequest(
    embed: embed,
    limit: limit,
    position: position,
    rest_api_id: rest_api_id,
  ))
}

pub type Resources {
  Resources(
    items: option.Option(List(Resource)),
    position: option.Option(String),
  )
}

pub fn encode_resources_struct(input: Resources) -> json.Json {
  let pairs = []
  let pairs = case input.items {
    option.Some(v) -> [
      #("item", fn(xs) { json.array(xs, encode_resource_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_resources_struct() -> decode.Decoder(Resources) {
  use <- decode.recursive
  use items <- decode.optional_field(
    "item",
    option.None,
    decode.optional(decode.list(decode_resource_struct())),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(Resources(items: items, position: position))
}

pub fn decode_resources_struct_params() -> decode.Decoder(Resources) {
  use <- decode.recursive
  use items <- decode.optional_field(
    "items",
    option.None,
    decode.optional(decode.list(decode_resource_struct_params())),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(Resources(items: items, position: position))
}

pub type GetRestApiRequest {
  GetRestApiRequest(rest_api_id: option.Option(String))
}

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

pub fn decode_get_rest_api_request_struct() -> decode.Decoder(GetRestApiRequest) {
  use <- decode.recursive
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetRestApiRequest(rest_api_id: rest_api_id))
}

pub fn decode_get_rest_api_request_struct_params() -> decode.Decoder(
  GetRestApiRequest,
) {
  use <- decode.recursive
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetRestApiRequest(rest_api_id: rest_api_id))
}

pub type GetRestApisRequest {
  GetRestApisRequest(limit: option.Option(Int), position: option.Option(String))
}

pub fn encode_get_rest_apis_request_struct(
  input: GetRestApisRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.limit {
    option.Some(v) -> [#("limit", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_rest_apis_request_struct() -> decode.Decoder(
  GetRestApisRequest,
) {
  use <- decode.recursive
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetRestApisRequest(limit: limit, position: position))
}

pub fn decode_get_rest_apis_request_struct_params() -> decode.Decoder(
  GetRestApisRequest,
) {
  use <- decode.recursive
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetRestApisRequest(limit: limit, position: position))
}

pub type RestApis {
  RestApis(items: option.Option(List(RestApi)), position: option.Option(String))
}

pub fn encode_rest_apis_struct(input: RestApis) -> json.Json {
  let pairs = []
  let pairs = case input.items {
    option.Some(v) -> [
      #("item", fn(xs) { json.array(xs, encode_rest_api_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_rest_apis_struct() -> decode.Decoder(RestApis) {
  use <- decode.recursive
  use items <- decode.optional_field(
    "item",
    option.None,
    decode.optional(decode.list(decode_rest_api_struct())),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(RestApis(items: items, position: position))
}

pub fn decode_rest_apis_struct_params() -> decode.Decoder(RestApis) {
  use <- decode.recursive
  use items <- decode.optional_field(
    "items",
    option.None,
    decode.optional(decode.list(decode_rest_api_struct_params())),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(RestApis(items: items, position: position))
}

pub type GetSdkRequest {
  GetSdkRequest(
    parameters: option.Option(dict.Dict(String, String)),
    rest_api_id: option.Option(String),
    sdk_type: option.Option(String),
    stage_name: option.Option(String),
  )
}

pub fn encode_get_sdk_request_struct(input: GetSdkRequest) -> json.Json {
  let pairs = []
  let pairs = case input.parameters {
    option.Some(v) -> [
      #(
        "parameters",
        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.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.sdk_type {
    option.Some(v) -> [#("sdkType", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.stage_name {
    option.Some(v) -> [#("stageName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_sdk_request_struct() -> decode.Decoder(GetSdkRequest) {
  use <- decode.recursive
  use parameters <- decode.optional_field(
    "parameters",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use sdk_type <- decode.optional_field(
    "sdkType",
    option.None,
    decode.optional(decode.string),
  )
  use stage_name <- decode.optional_field(
    "stageName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetSdkRequest(
    parameters: parameters,
    rest_api_id: rest_api_id,
    sdk_type: sdk_type,
    stage_name: stage_name,
  ))
}

pub fn decode_get_sdk_request_struct_params() -> decode.Decoder(GetSdkRequest) {
  use <- decode.recursive
  use parameters <- decode.optional_field(
    "parameters",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use sdk_type <- decode.optional_field(
    "sdkType",
    option.None,
    decode.optional(decode.string),
  )
  use stage_name <- decode.optional_field(
    "stageName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetSdkRequest(
    parameters: parameters,
    rest_api_id: rest_api_id,
    sdk_type: sdk_type,
    stage_name: stage_name,
  ))
}

pub type SdkResponse {
  SdkResponse(
    body: option.Option(BitArray),
    content_disposition: option.Option(String),
    content_type: option.Option(String),
  )
}

pub fn encode_sdk_response_struct(input: SdkResponse) -> json.Json {
  let pairs = []
  let pairs = case input.body {
    option.Some(v) -> [
      #("body", fn(b) { json.string(bit_array.base64_encode(b, True)) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.content_disposition {
    option.Some(v) -> [#("contentDisposition", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.content_type {
    option.Some(v) -> [#("contentType", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_sdk_response_struct() -> decode.Decoder(SdkResponse) {
  use <- decode.recursive
  use body <- decode.optional_field(
    "body",
    option.None,
    decode.optional(
      decode.then(decode.string, fn(s) {
        decode.success(bit_array.from_string(s))
      }),
    ),
  )
  use content_disposition <- decode.optional_field(
    "contentDisposition",
    option.None,
    decode.optional(decode.string),
  )
  use content_type <- decode.optional_field(
    "contentType",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(SdkResponse(
    body: body,
    content_disposition: content_disposition,
    content_type: content_type,
  ))
}

pub fn decode_sdk_response_struct_params() -> decode.Decoder(SdkResponse) {
  use <- decode.recursive
  use body <- decode.optional_field(
    "body",
    option.None,
    decode.optional(
      decode.then(decode.string, fn(s) {
        decode.success(bit_array.from_string(s))
      }),
    ),
  )
  use content_disposition <- decode.optional_field(
    "contentDisposition",
    option.None,
    decode.optional(decode.string),
  )
  use content_type <- decode.optional_field(
    "contentType",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(SdkResponse(
    body: body,
    content_disposition: content_disposition,
    content_type: content_type,
  ))
}

pub type GetSdkTypeRequest {
  GetSdkTypeRequest(id: option.Option(String))
}

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

pub fn decode_get_sdk_type_request_struct() -> decode.Decoder(GetSdkTypeRequest) {
  use <- decode.recursive
  use id <- decode.optional_field(
    "id",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetSdkTypeRequest(id: id))
}

pub fn decode_get_sdk_type_request_struct_params() -> decode.Decoder(
  GetSdkTypeRequest,
) {
  use <- decode.recursive
  use id <- decode.optional_field(
    "id",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetSdkTypeRequest(id: id))
}

pub type SdkType {
  SdkType(
    configuration_properties: option.Option(List(SdkConfigurationProperty)),
    description: option.Option(String),
    friendly_name: option.Option(String),
    id: option.Option(String),
  )
}

pub fn encode_sdk_type_struct(input: SdkType) -> json.Json {
  let pairs = []
  let pairs = case input.configuration_properties {
    option.Some(v) -> [
      #(
        "configurationProperties",
        fn(xs) { json.array(xs, encode_sdk_configuration_property_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.description {
    option.Some(v) -> [#("description", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.friendly_name {
    option.Some(v) -> [#("friendlyName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.id {
    option.Some(v) -> [#("id", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_sdk_type_struct() -> decode.Decoder(SdkType) {
  use <- decode.recursive
  use configuration_properties <- decode.optional_field(
    "configurationProperties",
    option.None,
    decode.optional(decode.list(decode_sdk_configuration_property_struct())),
  )
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use friendly_name <- decode.optional_field(
    "friendlyName",
    option.None,
    decode.optional(decode.string),
  )
  use id <- decode.optional_field(
    "id",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(SdkType(
    configuration_properties: configuration_properties,
    description: description,
    friendly_name: friendly_name,
    id: id,
  ))
}

pub fn decode_sdk_type_struct_params() -> decode.Decoder(SdkType) {
  use <- decode.recursive
  use configuration_properties <- decode.optional_field(
    "configurationProperties",
    option.None,
    decode.optional(
      decode.list(decode_sdk_configuration_property_struct_params()),
    ),
  )
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use friendly_name <- decode.optional_field(
    "friendlyName",
    option.None,
    decode.optional(decode.string),
  )
  use id <- decode.optional_field(
    "id",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(SdkType(
    configuration_properties: configuration_properties,
    description: description,
    friendly_name: friendly_name,
    id: id,
  ))
}

pub type SdkConfigurationProperty {
  SdkConfigurationProperty(
    default_value: option.Option(String),
    description: option.Option(String),
    friendly_name: option.Option(String),
    name: option.Option(String),
    required: option.Option(Bool),
  )
}

pub fn encode_sdk_configuration_property_struct(
  input: SdkConfigurationProperty,
) -> json.Json {
  let pairs = []
  let pairs = case input.default_value {
    option.Some(v) -> [#("defaultValue", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.description {
    option.Some(v) -> [#("description", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.friendly_name {
    option.Some(v) -> [#("friendlyName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.name {
    option.Some(v) -> [#("name", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.required {
    option.Some(v) -> [#("required", json.bool(v)), ..pairs]
    option.None -> [#("required", json.bool(False)), ..pairs]
  }
  json.object(pairs)
}

pub fn decode_sdk_configuration_property_struct() -> decode.Decoder(
  SdkConfigurationProperty,
) {
  use <- decode.recursive
  use default_value <- decode.optional_field(
    "defaultValue",
    option.None,
    decode.optional(decode.string),
  )
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use friendly_name <- decode.optional_field(
    "friendlyName",
    option.None,
    decode.optional(decode.string),
  )
  use name <- decode.optional_field(
    "name",
    option.None,
    decode.optional(decode.string),
  )
  use required <- decode.optional_field(
    "required",
    option.None,
    decode.optional(decode.bool),
  )
  decode.success(SdkConfigurationProperty(
    default_value: default_value,
    description: description,
    friendly_name: friendly_name,
    name: name,
    required: required,
  ))
}

pub fn decode_sdk_configuration_property_struct_params() -> decode.Decoder(
  SdkConfigurationProperty,
) {
  use <- decode.recursive
  use default_value <- decode.optional_field(
    "defaultValue",
    option.None,
    decode.optional(decode.string),
  )
  use description <- decode.optional_field(
    "description",
    option.None,
    decode.optional(decode.string),
  )
  use friendly_name <- decode.optional_field(
    "friendlyName",
    option.None,
    decode.optional(decode.string),
  )
  use name <- decode.optional_field(
    "name",
    option.None,
    decode.optional(decode.string),
  )
  use required <- decode.optional_field(
    "required",
    option.None,
    decode.optional(decode.bool),
  )
  decode.success(SdkConfigurationProperty(
    default_value: default_value,
    description: description,
    friendly_name: friendly_name,
    name: name,
    required: required,
  ))
}

pub type GetSdkTypesRequest {
  GetSdkTypesRequest(limit: option.Option(Int), position: option.Option(String))
}

pub fn encode_get_sdk_types_request_struct(
  input: GetSdkTypesRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.limit {
    option.Some(v) -> [#("limit", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_sdk_types_request_struct() -> decode.Decoder(
  GetSdkTypesRequest,
) {
  use <- decode.recursive
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetSdkTypesRequest(limit: limit, position: position))
}

pub fn decode_get_sdk_types_request_struct_params() -> decode.Decoder(
  GetSdkTypesRequest,
) {
  use <- decode.recursive
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetSdkTypesRequest(limit: limit, position: position))
}

pub type SdkTypes {
  SdkTypes(items: option.Option(List(SdkType)))
}

pub fn encode_sdk_types_struct(input: SdkTypes) -> json.Json {
  let pairs = []
  let pairs = case input.items {
    option.Some(v) -> [
      #("item", fn(xs) { json.array(xs, encode_sdk_type_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_sdk_types_struct() -> decode.Decoder(SdkTypes) {
  use <- decode.recursive
  use items <- decode.optional_field(
    "item",
    option.None,
    decode.optional(decode.list(decode_sdk_type_struct())),
  )
  decode.success(SdkTypes(items: items))
}

pub fn decode_sdk_types_struct_params() -> decode.Decoder(SdkTypes) {
  use <- decode.recursive
  use items <- decode.optional_field(
    "items",
    option.None,
    decode.optional(decode.list(decode_sdk_type_struct_params())),
  )
  decode.success(SdkTypes(items: items))
}

pub type GetStageRequest {
  GetStageRequest(
    rest_api_id: option.Option(String),
    stage_name: option.Option(String),
  )
}

pub fn encode_get_stage_request_struct(input: GetStageRequest) -> json.Json {
  let pairs = []
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.stage_name {
    option.Some(v) -> [#("stageName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_stage_request_struct() -> decode.Decoder(GetStageRequest) {
  use <- decode.recursive
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use stage_name <- decode.optional_field(
    "stageName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetStageRequest(
    rest_api_id: rest_api_id,
    stage_name: stage_name,
  ))
}

pub fn decode_get_stage_request_struct_params() -> decode.Decoder(
  GetStageRequest,
) {
  use <- decode.recursive
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use stage_name <- decode.optional_field(
    "stageName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetStageRequest(
    rest_api_id: rest_api_id,
    stage_name: stage_name,
  ))
}

pub type GetStagesRequest {
  GetStagesRequest(
    deployment_id: option.Option(String),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_get_stages_request_struct(input: GetStagesRequest) -> json.Json {
  let pairs = []
  let pairs = case input.deployment_id {
    option.Some(v) -> [#("deploymentId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_stages_request_struct() -> decode.Decoder(GetStagesRequest) {
  use <- decode.recursive
  use deployment_id <- decode.optional_field(
    "deploymentId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetStagesRequest(
    deployment_id: deployment_id,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_get_stages_request_struct_params() -> decode.Decoder(
  GetStagesRequest,
) {
  use <- decode.recursive
  use deployment_id <- decode.optional_field(
    "deploymentId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetStagesRequest(
    deployment_id: deployment_id,
    rest_api_id: rest_api_id,
  ))
}

pub type Stages {
  Stages(item: option.Option(List(Stage)))
}

pub fn encode_stages_struct(input: Stages) -> json.Json {
  let pairs = []
  let pairs = case input.item {
    option.Some(v) -> [
      #("item", fn(xs) { json.array(xs, encode_stage_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_stages_struct() -> decode.Decoder(Stages) {
  use <- decode.recursive
  use item <- decode.optional_field(
    "item",
    option.None,
    decode.optional(decode.list(decode_stage_struct())),
  )
  decode.success(Stages(item: item))
}

pub fn decode_stages_struct_params() -> decode.Decoder(Stages) {
  use <- decode.recursive
  use item <- decode.optional_field(
    "item",
    option.None,
    decode.optional(decode.list(decode_stage_struct_params())),
  )
  decode.success(Stages(item: item))
}

pub type GetTagsRequest {
  GetTagsRequest(
    limit: option.Option(Int),
    position: option.Option(String),
    resource_arn: option.Option(String),
  )
}

pub fn encode_get_tags_request_struct(input: GetTagsRequest) -> json.Json {
  let pairs = []
  let pairs = case input.limit {
    option.Some(v) -> [#("limit", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.position {
    option.Some(v) -> [#("position", 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_get_tags_request_struct() -> decode.Decoder(GetTagsRequest) {
  use <- decode.recursive
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  use resource_arn <- decode.optional_field(
    "resourceArn",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetTagsRequest(
    limit: limit,
    position: position,
    resource_arn: resource_arn,
  ))
}

pub fn decode_get_tags_request_struct_params() -> decode.Decoder(GetTagsRequest) {
  use <- decode.recursive
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  use resource_arn <- decode.optional_field(
    "resourceArn",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetTagsRequest(
    limit: limit,
    position: position,
    resource_arn: resource_arn,
  ))
}

pub type Tags {
  Tags(tags: option.Option(dict.Dict(String, String)))
}

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

pub fn decode_tags_struct() -> decode.Decoder(Tags) {
  use <- decode.recursive
  use tags <- decode.optional_field(
    "tags",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  decode.success(Tags(tags: tags))
}

pub fn decode_tags_struct_params() -> decode.Decoder(Tags) {
  use <- decode.recursive
  use tags <- decode.optional_field(
    "tags",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  decode.success(Tags(tags: tags))
}

pub type GetUsageRequest {
  GetUsageRequest(
    end_date: option.Option(String),
    key_id: option.Option(String),
    limit: option.Option(Int),
    position: option.Option(String),
    start_date: option.Option(String),
    usage_plan_id: option.Option(String),
  )
}

pub fn encode_get_usage_request_struct(input: GetUsageRequest) -> json.Json {
  let pairs = []
  let pairs = case input.end_date {
    option.Some(v) -> [#("endDate", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.key_id {
    option.Some(v) -> [#("keyId", 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.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.start_date {
    option.Some(v) -> [#("startDate", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.usage_plan_id {
    option.Some(v) -> [#("usagePlanId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_usage_request_struct() -> decode.Decoder(GetUsageRequest) {
  use <- decode.recursive
  use end_date <- decode.optional_field(
    "endDate",
    option.None,
    decode.optional(decode.string),
  )
  use key_id <- decode.optional_field(
    "keyId",
    option.None,
    decode.optional(decode.string),
  )
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  use start_date <- decode.optional_field(
    "startDate",
    option.None,
    decode.optional(decode.string),
  )
  use usage_plan_id <- decode.optional_field(
    "usagePlanId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetUsageRequest(
    end_date: end_date,
    key_id: key_id,
    limit: limit,
    position: position,
    start_date: start_date,
    usage_plan_id: usage_plan_id,
  ))
}

pub fn decode_get_usage_request_struct_params() -> decode.Decoder(
  GetUsageRequest,
) {
  use <- decode.recursive
  use end_date <- decode.optional_field(
    "endDate",
    option.None,
    decode.optional(decode.string),
  )
  use key_id <- decode.optional_field(
    "keyId",
    option.None,
    decode.optional(decode.string),
  )
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  use start_date <- decode.optional_field(
    "startDate",
    option.None,
    decode.optional(decode.string),
  )
  use usage_plan_id <- decode.optional_field(
    "usagePlanId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetUsageRequest(
    end_date: end_date,
    key_id: key_id,
    limit: limit,
    position: position,
    start_date: start_date,
    usage_plan_id: usage_plan_id,
  ))
}

pub type Usage {
  Usage(
    end_date: option.Option(String),
    items: option.Option(dict.Dict(String, List(List(Int)))),
    position: option.Option(String),
    start_date: option.Option(String),
    usage_plan_id: option.Option(String),
  )
}

pub fn encode_usage_struct(input: Usage) -> json.Json {
  let pairs = []
  let pairs = case input.end_date {
    option.Some(v) -> [#("endDate", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.items {
    option.Some(v) -> [
      #(
        "values",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(
                pair.0,
                fn(xs) { json.array(xs, fn(xs) { json.array(xs, json.int) }) }(
                  pair.1,
                ),
              )
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.start_date {
    option.Some(v) -> [#("startDate", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.usage_plan_id {
    option.Some(v) -> [#("usagePlanId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_usage_struct() -> decode.Decoder(Usage) {
  use <- decode.recursive
  use end_date <- decode.optional_field(
    "endDate",
    option.None,
    decode.optional(decode.string),
  )
  use items <- decode.optional_field(
    "values",
    option.None,
    decode.optional(decode.dict(
      decode.string,
      decode.list(decode.list(decode.int)),
    )),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  use start_date <- decode.optional_field(
    "startDate",
    option.None,
    decode.optional(decode.string),
  )
  use usage_plan_id <- decode.optional_field(
    "usagePlanId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(Usage(
    end_date: end_date,
    items: items,
    position: position,
    start_date: start_date,
    usage_plan_id: usage_plan_id,
  ))
}

pub fn decode_usage_struct_params() -> decode.Decoder(Usage) {
  use <- decode.recursive
  use end_date <- decode.optional_field(
    "endDate",
    option.None,
    decode.optional(decode.string),
  )
  use items <- decode.optional_field(
    "items",
    option.None,
    decode.optional(decode.dict(
      decode.string,
      decode.list(decode.list(decode.int)),
    )),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  use start_date <- decode.optional_field(
    "startDate",
    option.None,
    decode.optional(decode.string),
  )
  use usage_plan_id <- decode.optional_field(
    "usagePlanId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(Usage(
    end_date: end_date,
    items: items,
    position: position,
    start_date: start_date,
    usage_plan_id: usage_plan_id,
  ))
}

pub type GetUsagePlanRequest {
  GetUsagePlanRequest(usage_plan_id: option.Option(String))
}

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

pub fn decode_get_usage_plan_request_struct() -> decode.Decoder(
  GetUsagePlanRequest,
) {
  use <- decode.recursive
  use usage_plan_id <- decode.optional_field(
    "usagePlanId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetUsagePlanRequest(usage_plan_id: usage_plan_id))
}

pub fn decode_get_usage_plan_request_struct_params() -> decode.Decoder(
  GetUsagePlanRequest,
) {
  use <- decode.recursive
  use usage_plan_id <- decode.optional_field(
    "usagePlanId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetUsagePlanRequest(usage_plan_id: usage_plan_id))
}

pub type GetUsagePlanKeyRequest {
  GetUsagePlanKeyRequest(
    key_id: option.Option(String),
    usage_plan_id: option.Option(String),
  )
}

pub fn encode_get_usage_plan_key_request_struct(
  input: GetUsagePlanKeyRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.key_id {
    option.Some(v) -> [#("keyId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.usage_plan_id {
    option.Some(v) -> [#("usagePlanId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_usage_plan_key_request_struct() -> decode.Decoder(
  GetUsagePlanKeyRequest,
) {
  use <- decode.recursive
  use key_id <- decode.optional_field(
    "keyId",
    option.None,
    decode.optional(decode.string),
  )
  use usage_plan_id <- decode.optional_field(
    "usagePlanId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetUsagePlanKeyRequest(
    key_id: key_id,
    usage_plan_id: usage_plan_id,
  ))
}

pub fn decode_get_usage_plan_key_request_struct_params() -> decode.Decoder(
  GetUsagePlanKeyRequest,
) {
  use <- decode.recursive
  use key_id <- decode.optional_field(
    "keyId",
    option.None,
    decode.optional(decode.string),
  )
  use usage_plan_id <- decode.optional_field(
    "usagePlanId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetUsagePlanKeyRequest(
    key_id: key_id,
    usage_plan_id: usage_plan_id,
  ))
}

pub type GetUsagePlanKeysRequest {
  GetUsagePlanKeysRequest(
    limit: option.Option(Int),
    name_query: option.Option(String),
    position: option.Option(String),
    usage_plan_id: option.Option(String),
  )
}

pub fn encode_get_usage_plan_keys_request_struct(
  input: GetUsagePlanKeysRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.limit {
    option.Some(v) -> [#("limit", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.name_query {
    option.Some(v) -> [#("nameQuery", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.usage_plan_id {
    option.Some(v) -> [#("usagePlanId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_usage_plan_keys_request_struct() -> decode.Decoder(
  GetUsagePlanKeysRequest,
) {
  use <- decode.recursive
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use name_query <- decode.optional_field(
    "nameQuery",
    option.None,
    decode.optional(decode.string),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  use usage_plan_id <- decode.optional_field(
    "usagePlanId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetUsagePlanKeysRequest(
    limit: limit,
    name_query: name_query,
    position: position,
    usage_plan_id: usage_plan_id,
  ))
}

pub fn decode_get_usage_plan_keys_request_struct_params() -> decode.Decoder(
  GetUsagePlanKeysRequest,
) {
  use <- decode.recursive
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use name_query <- decode.optional_field(
    "nameQuery",
    option.None,
    decode.optional(decode.string),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  use usage_plan_id <- decode.optional_field(
    "usagePlanId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetUsagePlanKeysRequest(
    limit: limit,
    name_query: name_query,
    position: position,
    usage_plan_id: usage_plan_id,
  ))
}

pub type UsagePlanKeys {
  UsagePlanKeys(
    items: option.Option(List(UsagePlanKey)),
    position: option.Option(String),
  )
}

pub fn encode_usage_plan_keys_struct(input: UsagePlanKeys) -> json.Json {
  let pairs = []
  let pairs = case input.items {
    option.Some(v) -> [
      #("item", fn(xs) { json.array(xs, encode_usage_plan_key_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_usage_plan_keys_struct() -> decode.Decoder(UsagePlanKeys) {
  use <- decode.recursive
  use items <- decode.optional_field(
    "item",
    option.None,
    decode.optional(decode.list(decode_usage_plan_key_struct())),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UsagePlanKeys(items: items, position: position))
}

pub fn decode_usage_plan_keys_struct_params() -> decode.Decoder(UsagePlanKeys) {
  use <- decode.recursive
  use items <- decode.optional_field(
    "items",
    option.None,
    decode.optional(decode.list(decode_usage_plan_key_struct_params())),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UsagePlanKeys(items: items, position: position))
}

pub type GetUsagePlansRequest {
  GetUsagePlansRequest(
    key_id: option.Option(String),
    limit: option.Option(Int),
    position: option.Option(String),
  )
}

pub fn encode_get_usage_plans_request_struct(
  input: GetUsagePlansRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.key_id {
    option.Some(v) -> [#("keyId", 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.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_usage_plans_request_struct() -> decode.Decoder(
  GetUsagePlansRequest,
) {
  use <- decode.recursive
  use key_id <- decode.optional_field(
    "keyId",
    option.None,
    decode.optional(decode.string),
  )
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetUsagePlansRequest(
    key_id: key_id,
    limit: limit,
    position: position,
  ))
}

pub fn decode_get_usage_plans_request_struct_params() -> decode.Decoder(
  GetUsagePlansRequest,
) {
  use <- decode.recursive
  use key_id <- decode.optional_field(
    "keyId",
    option.None,
    decode.optional(decode.string),
  )
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetUsagePlansRequest(
    key_id: key_id,
    limit: limit,
    position: position,
  ))
}

pub type UsagePlans {
  UsagePlans(
    items: option.Option(List(UsagePlan)),
    position: option.Option(String),
  )
}

pub fn encode_usage_plans_struct(input: UsagePlans) -> json.Json {
  let pairs = []
  let pairs = case input.items {
    option.Some(v) -> [
      #("item", fn(xs) { json.array(xs, encode_usage_plan_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_usage_plans_struct() -> decode.Decoder(UsagePlans) {
  use <- decode.recursive
  use items <- decode.optional_field(
    "item",
    option.None,
    decode.optional(decode.list(decode_usage_plan_struct())),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UsagePlans(items: items, position: position))
}

pub fn decode_usage_plans_struct_params() -> decode.Decoder(UsagePlans) {
  use <- decode.recursive
  use items <- decode.optional_field(
    "items",
    option.None,
    decode.optional(decode.list(decode_usage_plan_struct_params())),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UsagePlans(items: items, position: position))
}

pub type GetVpcLinkRequest {
  GetVpcLinkRequest(vpc_link_id: option.Option(String))
}

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

pub fn decode_get_vpc_link_request_struct() -> decode.Decoder(GetVpcLinkRequest) {
  use <- decode.recursive
  use vpc_link_id <- decode.optional_field(
    "vpcLinkId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetVpcLinkRequest(vpc_link_id: vpc_link_id))
}

pub fn decode_get_vpc_link_request_struct_params() -> decode.Decoder(
  GetVpcLinkRequest,
) {
  use <- decode.recursive
  use vpc_link_id <- decode.optional_field(
    "vpcLinkId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetVpcLinkRequest(vpc_link_id: vpc_link_id))
}

pub type GetVpcLinksRequest {
  GetVpcLinksRequest(limit: option.Option(Int), position: option.Option(String))
}

pub fn encode_get_vpc_links_request_struct(
  input: GetVpcLinksRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.limit {
    option.Some(v) -> [#("limit", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_get_vpc_links_request_struct() -> decode.Decoder(
  GetVpcLinksRequest,
) {
  use <- decode.recursive
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetVpcLinksRequest(limit: limit, position: position))
}

pub fn decode_get_vpc_links_request_struct_params() -> decode.Decoder(
  GetVpcLinksRequest,
) {
  use <- decode.recursive
  use limit <- decode.optional_field(
    "limit",
    option.None,
    decode.optional(decode.int),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(GetVpcLinksRequest(limit: limit, position: position))
}

pub type VpcLinks {
  VpcLinks(items: option.Option(List(VpcLink)), position: option.Option(String))
}

pub fn encode_vpc_links_struct(input: VpcLinks) -> json.Json {
  let pairs = []
  let pairs = case input.items {
    option.Some(v) -> [
      #("item", fn(xs) { json.array(xs, encode_vpc_link_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.position {
    option.Some(v) -> [#("position", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_vpc_links_struct() -> decode.Decoder(VpcLinks) {
  use <- decode.recursive
  use items <- decode.optional_field(
    "item",
    option.None,
    decode.optional(decode.list(decode_vpc_link_struct())),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(VpcLinks(items: items, position: position))
}

pub fn decode_vpc_links_struct_params() -> decode.Decoder(VpcLinks) {
  use <- decode.recursive
  use items <- decode.optional_field(
    "items",
    option.None,
    decode.optional(decode.list(decode_vpc_link_struct_params())),
  )
  use position <- decode.optional_field(
    "position",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(VpcLinks(items: items, position: position))
}

pub type ImportApiKeysRequest {
  ImportApiKeysRequest(
    body: option.Option(BitArray),
    fail_on_warnings: option.Option(Bool),
    format: option.Option(ApiKeysFormat),
  )
}

pub fn encode_import_api_keys_request_struct(
  input: ImportApiKeysRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.body {
    option.Some(v) -> [
      #("body", fn(b) { json.string(bit_array.base64_encode(b, True)) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.fail_on_warnings {
    option.Some(v) -> [#("failOnWarnings", json.bool(v)), ..pairs]
    option.None -> [#("failOnWarnings", json.bool(False)), ..pairs]
  }
  let pairs = case input.format {
    option.Some(v) -> [#("format", encode_api_keys_format_enum(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_import_api_keys_request_struct() -> decode.Decoder(
  ImportApiKeysRequest,
) {
  use <- decode.recursive
  use body <- decode.optional_field(
    "body",
    option.None,
    decode.optional(
      decode.then(decode.string, fn(s) {
        decode.success(bit_array.from_string(s))
      }),
    ),
  )
  use fail_on_warnings <- decode.optional_field(
    "failOnWarnings",
    option.None,
    decode.optional(decode.bool),
  )
  use format <- decode.optional_field(
    "format",
    option.None,
    decode.optional(decode_api_keys_format_enum()),
  )
  decode.success(ImportApiKeysRequest(
    body: body,
    fail_on_warnings: fail_on_warnings,
    format: format,
  ))
}

pub fn decode_import_api_keys_request_struct_params() -> decode.Decoder(
  ImportApiKeysRequest,
) {
  use <- decode.recursive
  use body <- decode.optional_field(
    "body",
    option.None,
    decode.optional(
      decode.then(decode.string, fn(s) {
        decode.success(bit_array.from_string(s))
      }),
    ),
  )
  use fail_on_warnings <- decode.optional_field(
    "failOnWarnings",
    option.None,
    decode.optional(decode.bool),
  )
  use format <- decode.optional_field(
    "format",
    option.None,
    decode.optional(decode_api_keys_format_enum()),
  )
  decode.success(ImportApiKeysRequest(
    body: body,
    fail_on_warnings: fail_on_warnings,
    format: format,
  ))
}

pub type ApiKeysFormat {
  ApiKeysFormatCsv
}

pub fn encode_api_keys_format_enum(v: ApiKeysFormat) -> json.Json {
  case v {
    ApiKeysFormatCsv -> json.string("csv")
  }
}

pub fn decode_api_keys_format_enum() -> decode.Decoder(ApiKeysFormat) {
  decode.then(decode.string, fn(s) {
    case s {
      "csv" -> decode.success(ApiKeysFormatCsv)
      _ -> decode.failure(ApiKeysFormatCsv, "unknown enum value")
    }
  })
}

pub fn api_keys_format_from_wire(s: String) -> Result(ApiKeysFormat, String) {
  case s {
    "csv" -> Ok(ApiKeysFormatCsv)
    _ -> Ok(ApiKeysFormatCsv)
  }
}

pub type ApiKeyIds {
  ApiKeyIds(
    ids: option.Option(List(String)),
    warnings: option.Option(List(String)),
  )
}

pub fn encode_api_key_ids_struct(input: ApiKeyIds) -> json.Json {
  let pairs = []
  let pairs = case input.ids {
    option.Some(v) -> [
      #("ids", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.warnings {
    option.Some(v) -> [
      #("warnings", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_api_key_ids_struct() -> decode.Decoder(ApiKeyIds) {
  use <- decode.recursive
  use ids <- decode.optional_field(
    "ids",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  use warnings <- decode.optional_field(
    "warnings",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  decode.success(ApiKeyIds(ids: ids, warnings: warnings))
}

pub fn decode_api_key_ids_struct_params() -> decode.Decoder(ApiKeyIds) {
  use <- decode.recursive
  use ids <- decode.optional_field(
    "ids",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  use warnings <- decode.optional_field(
    "warnings",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  decode.success(ApiKeyIds(ids: ids, warnings: warnings))
}

pub type ImportDocumentationPartsRequest {
  ImportDocumentationPartsRequest(
    body: option.Option(BitArray),
    fail_on_warnings: option.Option(Bool),
    mode: option.Option(PutMode),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_import_documentation_parts_request_struct(
  input: ImportDocumentationPartsRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.body {
    option.Some(v) -> [
      #("body", fn(b) { json.string(bit_array.base64_encode(b, True)) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.fail_on_warnings {
    option.Some(v) -> [#("failOnWarnings", json.bool(v)), ..pairs]
    option.None -> [#("failOnWarnings", json.bool(False)), ..pairs]
  }
  let pairs = case input.mode {
    option.Some(v) -> [#("mode", encode_put_mode_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_import_documentation_parts_request_struct() -> decode.Decoder(
  ImportDocumentationPartsRequest,
) {
  use <- decode.recursive
  use body <- decode.optional_field(
    "body",
    option.None,
    decode.optional(
      decode.then(decode.string, fn(s) {
        decode.success(bit_array.from_string(s))
      }),
    ),
  )
  use fail_on_warnings <- decode.optional_field(
    "failOnWarnings",
    option.None,
    decode.optional(decode.bool),
  )
  use mode <- decode.optional_field(
    "mode",
    option.None,
    decode.optional(decode_put_mode_enum()),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ImportDocumentationPartsRequest(
    body: body,
    fail_on_warnings: fail_on_warnings,
    mode: mode,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_import_documentation_parts_request_struct_params() -> decode.Decoder(
  ImportDocumentationPartsRequest,
) {
  use <- decode.recursive
  use body <- decode.optional_field(
    "body",
    option.None,
    decode.optional(
      decode.then(decode.string, fn(s) {
        decode.success(bit_array.from_string(s))
      }),
    ),
  )
  use fail_on_warnings <- decode.optional_field(
    "failOnWarnings",
    option.None,
    decode.optional(decode.bool),
  )
  use mode <- decode.optional_field(
    "mode",
    option.None,
    decode.optional(decode_put_mode_enum()),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(ImportDocumentationPartsRequest(
    body: body,
    fail_on_warnings: fail_on_warnings,
    mode: mode,
    rest_api_id: rest_api_id,
  ))
}

pub type PutMode {
  PutModeMerge
  PutModeOverwrite
}

pub fn encode_put_mode_enum(v: PutMode) -> json.Json {
  case v {
    PutModeMerge -> json.string("merge")
    PutModeOverwrite -> json.string("overwrite")
  }
}

pub fn decode_put_mode_enum() -> decode.Decoder(PutMode) {
  decode.then(decode.string, fn(s) {
    case s {
      "merge" -> decode.success(PutModeMerge)
      "overwrite" -> decode.success(PutModeOverwrite)
      _ -> decode.failure(PutModeMerge, "unknown enum value")
    }
  })
}

pub fn put_mode_from_wire(s: String) -> Result(PutMode, String) {
  case s {
    "merge" -> Ok(PutModeMerge)
    "overwrite" -> Ok(PutModeOverwrite)
    _ -> Ok(PutModeMerge)
  }
}

pub type DocumentationPartIds {
  DocumentationPartIds(
    ids: option.Option(List(String)),
    warnings: option.Option(List(String)),
  )
}

pub fn encode_documentation_part_ids_struct(
  input: DocumentationPartIds,
) -> json.Json {
  let pairs = []
  let pairs = case input.ids {
    option.Some(v) -> [
      #("ids", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.warnings {
    option.Some(v) -> [
      #("warnings", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_documentation_part_ids_struct() -> decode.Decoder(
  DocumentationPartIds,
) {
  use <- decode.recursive
  use ids <- decode.optional_field(
    "ids",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  use warnings <- decode.optional_field(
    "warnings",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  decode.success(DocumentationPartIds(ids: ids, warnings: warnings))
}

pub fn decode_documentation_part_ids_struct_params() -> decode.Decoder(
  DocumentationPartIds,
) {
  use <- decode.recursive
  use ids <- decode.optional_field(
    "ids",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  use warnings <- decode.optional_field(
    "warnings",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  decode.success(DocumentationPartIds(ids: ids, warnings: warnings))
}

pub type ImportRestApiRequest {
  ImportRestApiRequest(
    body: option.Option(BitArray),
    fail_on_warnings: option.Option(Bool),
    parameters: option.Option(dict.Dict(String, String)),
  )
}

pub fn encode_import_rest_api_request_struct(
  input: ImportRestApiRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.body {
    option.Some(v) -> [
      #("body", fn(b) { json.string(bit_array.base64_encode(b, True)) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.fail_on_warnings {
    option.Some(v) -> [#("failOnWarnings", json.bool(v)), ..pairs]
    option.None -> [#("failOnWarnings", json.bool(False)), ..pairs]
  }
  let pairs = case input.parameters {
    option.Some(v) -> [
      #(
        "parameters",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_import_rest_api_request_struct() -> decode.Decoder(
  ImportRestApiRequest,
) {
  use <- decode.recursive
  use body <- decode.optional_field(
    "body",
    option.None,
    decode.optional(
      decode.then(decode.string, fn(s) {
        decode.success(bit_array.from_string(s))
      }),
    ),
  )
  use fail_on_warnings <- decode.optional_field(
    "failOnWarnings",
    option.None,
    decode.optional(decode.bool),
  )
  use parameters <- decode.optional_field(
    "parameters",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  decode.success(ImportRestApiRequest(
    body: body,
    fail_on_warnings: fail_on_warnings,
    parameters: parameters,
  ))
}

pub fn decode_import_rest_api_request_struct_params() -> decode.Decoder(
  ImportRestApiRequest,
) {
  use <- decode.recursive
  use body <- decode.optional_field(
    "body",
    option.None,
    decode.optional(
      decode.then(decode.string, fn(s) {
        decode.success(bit_array.from_string(s))
      }),
    ),
  )
  use fail_on_warnings <- decode.optional_field(
    "failOnWarnings",
    option.None,
    decode.optional(decode.bool),
  )
  use parameters <- decode.optional_field(
    "parameters",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  decode.success(ImportRestApiRequest(
    body: body,
    fail_on_warnings: fail_on_warnings,
    parameters: parameters,
  ))
}

pub type PutGatewayResponseRequest {
  PutGatewayResponseRequest(
    response_parameters: option.Option(dict.Dict(String, String)),
    response_templates: option.Option(dict.Dict(String, String)),
    response_type: option.Option(GatewayResponseType),
    rest_api_id: option.Option(String),
    status_code: option.Option(String),
  )
}

pub fn encode_put_gateway_response_request_struct(
  input: PutGatewayResponseRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.response_parameters {
    option.Some(v) -> [
      #(
        "responseParameters",
        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.response_templates {
    option.Some(v) -> [
      #(
        "responseTemplates",
        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.response_type {
    option.Some(v) -> [
      #("responseType", encode_gateway_response_type_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.status_code {
    option.Some(v) -> [#("statusCode", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_put_gateway_response_request_struct() -> decode.Decoder(
  PutGatewayResponseRequest,
) {
  use <- decode.recursive
  use response_parameters <- decode.optional_field(
    "responseParameters",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use response_templates <- decode.optional_field(
    "responseTemplates",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use response_type <- decode.optional_field(
    "responseType",
    option.None,
    decode.optional(decode_gateway_response_type_enum()),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use status_code <- decode.optional_field(
    "statusCode",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(PutGatewayResponseRequest(
    response_parameters: response_parameters,
    response_templates: response_templates,
    response_type: response_type,
    rest_api_id: rest_api_id,
    status_code: status_code,
  ))
}

pub fn decode_put_gateway_response_request_struct_params() -> decode.Decoder(
  PutGatewayResponseRequest,
) {
  use <- decode.recursive
  use response_parameters <- decode.optional_field(
    "responseParameters",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use response_templates <- decode.optional_field(
    "responseTemplates",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use response_type <- decode.optional_field(
    "responseType",
    option.None,
    decode.optional(decode_gateway_response_type_enum()),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use status_code <- decode.optional_field(
    "statusCode",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(PutGatewayResponseRequest(
    response_parameters: response_parameters,
    response_templates: response_templates,
    response_type: response_type,
    rest_api_id: rest_api_id,
    status_code: status_code,
  ))
}

pub type PutIntegrationRequest {
  PutIntegrationRequest(
    cache_key_parameters: option.Option(List(String)),
    cache_namespace: option.Option(String),
    connection_id: option.Option(String),
    connection_type: option.Option(ConnectionType),
    content_handling: option.Option(ContentHandlingStrategy),
    credentials: option.Option(String),
    http_method: option.Option(String),
    integration_http_method: option.Option(String),
    integration_target: option.Option(String),
    passthrough_behavior: option.Option(String),
    request_parameters: option.Option(dict.Dict(String, String)),
    request_templates: option.Option(dict.Dict(String, String)),
    resource_id: option.Option(String),
    response_transfer_mode: option.Option(ResponseTransferMode),
    rest_api_id: option.Option(String),
    timeout_in_millis: option.Option(Int),
    tls_config: option.Option(TlsConfig),
    type_: option.Option(IntegrationType),
    uri: option.Option(String),
  )
}

pub fn encode_put_integration_request_struct(
  input: PutIntegrationRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.cache_key_parameters {
    option.Some(v) -> [
      #("cacheKeyParameters", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.cache_namespace {
    option.Some(v) -> [#("cacheNamespace", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.connection_id {
    option.Some(v) -> [#("connectionId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.connection_type {
    option.Some(v) -> [
      #("connectionType", encode_connection_type_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.content_handling {
    option.Some(v) -> [
      #("contentHandling", encode_content_handling_strategy_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.credentials {
    option.Some(v) -> [#("credentials", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.http_method {
    option.Some(v) -> [#("requestHttpMethod", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.integration_http_method {
    option.Some(v) -> [#("httpMethod", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.integration_target {
    option.Some(v) -> [#("integrationTarget", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.passthrough_behavior {
    option.Some(v) -> [#("passthroughBehavior", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.request_parameters {
    option.Some(v) -> [
      #(
        "requestParameters",
        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.request_templates {
    option.Some(v) -> [
      #(
        "requestTemplates",
        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.resource_id {
    option.Some(v) -> [#("resourceId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.response_transfer_mode {
    option.Some(v) -> [
      #("responseTransferMode", encode_response_transfer_mode_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.timeout_in_millis {
    option.Some(v) -> [#("timeoutInMillis", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.tls_config {
    option.Some(v) -> [#("tlsConfig", encode_tls_config_struct(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.type_ {
    option.Some(v) -> [#("type", encode_integration_type_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.uri {
    option.Some(v) -> [#("uri", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_put_integration_request_struct() -> decode.Decoder(
  PutIntegrationRequest,
) {
  use <- decode.recursive
  use cache_key_parameters <- decode.optional_field(
    "cacheKeyParameters",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  use cache_namespace <- decode.optional_field(
    "cacheNamespace",
    option.None,
    decode.optional(decode.string),
  )
  use connection_id <- decode.optional_field(
    "connectionId",
    option.None,
    decode.optional(decode.string),
  )
  use connection_type <- decode.optional_field(
    "connectionType",
    option.None,
    decode.optional(decode_connection_type_enum()),
  )
  use content_handling <- decode.optional_field(
    "contentHandling",
    option.None,
    decode.optional(decode_content_handling_strategy_enum()),
  )
  use credentials <- decode.optional_field(
    "credentials",
    option.None,
    decode.optional(decode.string),
  )
  use http_method <- decode.optional_field(
    "requestHttpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use integration_http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use integration_target <- decode.optional_field(
    "integrationTarget",
    option.None,
    decode.optional(decode.string),
  )
  use passthrough_behavior <- decode.optional_field(
    "passthroughBehavior",
    option.None,
    decode.optional(decode.string),
  )
  use request_parameters <- decode.optional_field(
    "requestParameters",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use request_templates <- decode.optional_field(
    "requestTemplates",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use response_transfer_mode <- decode.optional_field(
    "responseTransferMode",
    option.None,
    decode.optional(decode_response_transfer_mode_enum()),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use timeout_in_millis <- decode.optional_field(
    "timeoutInMillis",
    option.None,
    decode.optional(decode.int),
  )
  use tls_config <- decode.optional_field(
    "tlsConfig",
    option.None,
    decode.optional(decode_tls_config_struct()),
  )
  use type_ <- decode.optional_field(
    "type",
    option.None,
    decode.optional(decode_integration_type_enum()),
  )
  use uri <- decode.optional_field(
    "uri",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(PutIntegrationRequest(
    cache_key_parameters: cache_key_parameters,
    cache_namespace: cache_namespace,
    connection_id: connection_id,
    connection_type: connection_type,
    content_handling: content_handling,
    credentials: credentials,
    http_method: http_method,
    integration_http_method: integration_http_method,
    integration_target: integration_target,
    passthrough_behavior: passthrough_behavior,
    request_parameters: request_parameters,
    request_templates: request_templates,
    resource_id: resource_id,
    response_transfer_mode: response_transfer_mode,
    rest_api_id: rest_api_id,
    timeout_in_millis: timeout_in_millis,
    tls_config: tls_config,
    type_: type_,
    uri: uri,
  ))
}

pub fn decode_put_integration_request_struct_params() -> decode.Decoder(
  PutIntegrationRequest,
) {
  use <- decode.recursive
  use cache_key_parameters <- decode.optional_field(
    "cacheKeyParameters",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  use cache_namespace <- decode.optional_field(
    "cacheNamespace",
    option.None,
    decode.optional(decode.string),
  )
  use connection_id <- decode.optional_field(
    "connectionId",
    option.None,
    decode.optional(decode.string),
  )
  use connection_type <- decode.optional_field(
    "connectionType",
    option.None,
    decode.optional(decode_connection_type_enum()),
  )
  use content_handling <- decode.optional_field(
    "contentHandling",
    option.None,
    decode.optional(decode_content_handling_strategy_enum()),
  )
  use credentials <- decode.optional_field(
    "credentials",
    option.None,
    decode.optional(decode.string),
  )
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use integration_http_method <- decode.optional_field(
    "integrationHttpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use integration_target <- decode.optional_field(
    "integrationTarget",
    option.None,
    decode.optional(decode.string),
  )
  use passthrough_behavior <- decode.optional_field(
    "passthroughBehavior",
    option.None,
    decode.optional(decode.string),
  )
  use request_parameters <- decode.optional_field(
    "requestParameters",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use request_templates <- decode.optional_field(
    "requestTemplates",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use response_transfer_mode <- decode.optional_field(
    "responseTransferMode",
    option.None,
    decode.optional(decode_response_transfer_mode_enum()),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use timeout_in_millis <- decode.optional_field(
    "timeoutInMillis",
    option.None,
    decode.optional(decode.int),
  )
  use tls_config <- decode.optional_field(
    "tlsConfig",
    option.None,
    decode.optional(decode_tls_config_struct_params()),
  )
  use type_ <- decode.optional_field(
    "type",
    option.None,
    decode.optional(decode_integration_type_enum()),
  )
  use uri <- decode.optional_field(
    "uri",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(PutIntegrationRequest(
    cache_key_parameters: cache_key_parameters,
    cache_namespace: cache_namespace,
    connection_id: connection_id,
    connection_type: connection_type,
    content_handling: content_handling,
    credentials: credentials,
    http_method: http_method,
    integration_http_method: integration_http_method,
    integration_target: integration_target,
    passthrough_behavior: passthrough_behavior,
    request_parameters: request_parameters,
    request_templates: request_templates,
    resource_id: resource_id,
    response_transfer_mode: response_transfer_mode,
    rest_api_id: rest_api_id,
    timeout_in_millis: timeout_in_millis,
    tls_config: tls_config,
    type_: type_,
    uri: uri,
  ))
}

pub type PutIntegrationResponseRequest {
  PutIntegrationResponseRequest(
    content_handling: option.Option(ContentHandlingStrategy),
    http_method: option.Option(String),
    resource_id: option.Option(String),
    response_parameters: option.Option(dict.Dict(String, String)),
    response_templates: option.Option(dict.Dict(String, String)),
    rest_api_id: option.Option(String),
    selection_pattern: option.Option(String),
    status_code: option.Option(String),
  )
}

pub fn encode_put_integration_response_request_struct(
  input: PutIntegrationResponseRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.content_handling {
    option.Some(v) -> [
      #("contentHandling", encode_content_handling_strategy_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.http_method {
    option.Some(v) -> [#("httpMethod", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.resource_id {
    option.Some(v) -> [#("resourceId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.response_parameters {
    option.Some(v) -> [
      #(
        "responseParameters",
        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.response_templates {
    option.Some(v) -> [
      #(
        "responseTemplates",
        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.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.selection_pattern {
    option.Some(v) -> [#("selectionPattern", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.status_code {
    option.Some(v) -> [#("statusCode", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_put_integration_response_request_struct() -> decode.Decoder(
  PutIntegrationResponseRequest,
) {
  use <- decode.recursive
  use content_handling <- decode.optional_field(
    "contentHandling",
    option.None,
    decode.optional(decode_content_handling_strategy_enum()),
  )
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use response_parameters <- decode.optional_field(
    "responseParameters",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use response_templates <- decode.optional_field(
    "responseTemplates",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use selection_pattern <- decode.optional_field(
    "selectionPattern",
    option.None,
    decode.optional(decode.string),
  )
  use status_code <- decode.optional_field(
    "statusCode",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(PutIntegrationResponseRequest(
    content_handling: content_handling,
    http_method: http_method,
    resource_id: resource_id,
    response_parameters: response_parameters,
    response_templates: response_templates,
    rest_api_id: rest_api_id,
    selection_pattern: selection_pattern,
    status_code: status_code,
  ))
}

pub fn decode_put_integration_response_request_struct_params() -> decode.Decoder(
  PutIntegrationResponseRequest,
) {
  use <- decode.recursive
  use content_handling <- decode.optional_field(
    "contentHandling",
    option.None,
    decode.optional(decode_content_handling_strategy_enum()),
  )
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use response_parameters <- decode.optional_field(
    "responseParameters",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use response_templates <- decode.optional_field(
    "responseTemplates",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use selection_pattern <- decode.optional_field(
    "selectionPattern",
    option.None,
    decode.optional(decode.string),
  )
  use status_code <- decode.optional_field(
    "statusCode",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(PutIntegrationResponseRequest(
    content_handling: content_handling,
    http_method: http_method,
    resource_id: resource_id,
    response_parameters: response_parameters,
    response_templates: response_templates,
    rest_api_id: rest_api_id,
    selection_pattern: selection_pattern,
    status_code: status_code,
  ))
}

pub type PutMethodRequest {
  PutMethodRequest(
    api_key_required: option.Option(Bool),
    authorization_scopes: option.Option(List(String)),
    authorization_type: option.Option(String),
    authorizer_id: option.Option(String),
    http_method: option.Option(String),
    operation_name: option.Option(String),
    request_models: option.Option(dict.Dict(String, String)),
    request_parameters: option.Option(dict.Dict(String, Bool)),
    request_validator_id: option.Option(String),
    resource_id: option.Option(String),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_put_method_request_struct(input: PutMethodRequest) -> json.Json {
  let pairs = []
  let pairs = case input.api_key_required {
    option.Some(v) -> [#("apiKeyRequired", json.bool(v)), ..pairs]
    option.None -> [#("apiKeyRequired", json.bool(False)), ..pairs]
  }
  let pairs = case input.authorization_scopes {
    option.Some(v) -> [
      #("authorizationScopes", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.authorization_type {
    option.Some(v) -> [#("authorizationType", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.authorizer_id {
    option.Some(v) -> [#("authorizerId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.http_method {
    option.Some(v) -> [#("httpMethod", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.operation_name {
    option.Some(v) -> [#("operationName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.request_models {
    option.Some(v) -> [
      #(
        "requestModels",
        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.request_parameters {
    option.Some(v) -> [
      #(
        "requestParameters",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.bool(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.request_validator_id {
    option.Some(v) -> [#("requestValidatorId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.resource_id {
    option.Some(v) -> [#("resourceId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_put_method_request_struct() -> decode.Decoder(PutMethodRequest) {
  use <- decode.recursive
  use api_key_required <- decode.optional_field(
    "apiKeyRequired",
    option.None,
    decode.optional(decode.bool),
  )
  use authorization_scopes <- decode.optional_field(
    "authorizationScopes",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  use authorization_type <- decode.optional_field(
    "authorizationType",
    option.None,
    decode.optional(decode.string),
  )
  use authorizer_id <- decode.optional_field(
    "authorizerId",
    option.None,
    decode.optional(decode.string),
  )
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use operation_name <- decode.optional_field(
    "operationName",
    option.None,
    decode.optional(decode.string),
  )
  use request_models <- decode.optional_field(
    "requestModels",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use request_parameters <- decode.optional_field(
    "requestParameters",
    option.None,
    decode.optional(decode.dict(decode.string, decode.bool)),
  )
  use request_validator_id <- decode.optional_field(
    "requestValidatorId",
    option.None,
    decode.optional(decode.string),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(PutMethodRequest(
    api_key_required: api_key_required,
    authorization_scopes: authorization_scopes,
    authorization_type: authorization_type,
    authorizer_id: authorizer_id,
    http_method: http_method,
    operation_name: operation_name,
    request_models: request_models,
    request_parameters: request_parameters,
    request_validator_id: request_validator_id,
    resource_id: resource_id,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_put_method_request_struct_params() -> decode.Decoder(
  PutMethodRequest,
) {
  use <- decode.recursive
  use api_key_required <- decode.optional_field(
    "apiKeyRequired",
    option.None,
    decode.optional(decode.bool),
  )
  use authorization_scopes <- decode.optional_field(
    "authorizationScopes",
    option.None,
    decode.optional(decode.list(decode.string)),
  )
  use authorization_type <- decode.optional_field(
    "authorizationType",
    option.None,
    decode.optional(decode.string),
  )
  use authorizer_id <- decode.optional_field(
    "authorizerId",
    option.None,
    decode.optional(decode.string),
  )
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use operation_name <- decode.optional_field(
    "operationName",
    option.None,
    decode.optional(decode.string),
  )
  use request_models <- decode.optional_field(
    "requestModels",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use request_parameters <- decode.optional_field(
    "requestParameters",
    option.None,
    decode.optional(decode.dict(decode.string, decode.bool)),
  )
  use request_validator_id <- decode.optional_field(
    "requestValidatorId",
    option.None,
    decode.optional(decode.string),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(PutMethodRequest(
    api_key_required: api_key_required,
    authorization_scopes: authorization_scopes,
    authorization_type: authorization_type,
    authorizer_id: authorizer_id,
    http_method: http_method,
    operation_name: operation_name,
    request_models: request_models,
    request_parameters: request_parameters,
    request_validator_id: request_validator_id,
    resource_id: resource_id,
    rest_api_id: rest_api_id,
  ))
}

pub type PutMethodResponseRequest {
  PutMethodResponseRequest(
    http_method: option.Option(String),
    resource_id: option.Option(String),
    response_models: option.Option(dict.Dict(String, String)),
    response_parameters: option.Option(dict.Dict(String, Bool)),
    rest_api_id: option.Option(String),
    status_code: option.Option(String),
  )
}

pub fn encode_put_method_response_request_struct(
  input: PutMethodResponseRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.http_method {
    option.Some(v) -> [#("httpMethod", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.resource_id {
    option.Some(v) -> [#("resourceId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.response_models {
    option.Some(v) -> [
      #(
        "responseModels",
        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.response_parameters {
    option.Some(v) -> [
      #(
        "responseParameters",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.bool(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.status_code {
    option.Some(v) -> [#("statusCode", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_put_method_response_request_struct() -> decode.Decoder(
  PutMethodResponseRequest,
) {
  use <- decode.recursive
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use response_models <- decode.optional_field(
    "responseModels",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use response_parameters <- decode.optional_field(
    "responseParameters",
    option.None,
    decode.optional(decode.dict(decode.string, decode.bool)),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use status_code <- decode.optional_field(
    "statusCode",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(PutMethodResponseRequest(
    http_method: http_method,
    resource_id: resource_id,
    response_models: response_models,
    response_parameters: response_parameters,
    rest_api_id: rest_api_id,
    status_code: status_code,
  ))
}

pub fn decode_put_method_response_request_struct_params() -> decode.Decoder(
  PutMethodResponseRequest,
) {
  use <- decode.recursive
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use response_models <- decode.optional_field(
    "responseModels",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use response_parameters <- decode.optional_field(
    "responseParameters",
    option.None,
    decode.optional(decode.dict(decode.string, decode.bool)),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use status_code <- decode.optional_field(
    "statusCode",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(PutMethodResponseRequest(
    http_method: http_method,
    resource_id: resource_id,
    response_models: response_models,
    response_parameters: response_parameters,
    rest_api_id: rest_api_id,
    status_code: status_code,
  ))
}

pub type PutRestApiRequest {
  PutRestApiRequest(
    body: option.Option(BitArray),
    fail_on_warnings: option.Option(Bool),
    mode: option.Option(PutMode),
    parameters: option.Option(dict.Dict(String, String)),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_put_rest_api_request_struct(
  input: PutRestApiRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.body {
    option.Some(v) -> [
      #("body", fn(b) { json.string(bit_array.base64_encode(b, True)) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.fail_on_warnings {
    option.Some(v) -> [#("failOnWarnings", json.bool(v)), ..pairs]
    option.None -> [#("failOnWarnings", json.bool(False)), ..pairs]
  }
  let pairs = case input.mode {
    option.Some(v) -> [#("mode", encode_put_mode_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.parameters {
    option.Some(v) -> [
      #(
        "parameters",
        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.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_put_rest_api_request_struct() -> decode.Decoder(PutRestApiRequest) {
  use <- decode.recursive
  use body <- decode.optional_field(
    "body",
    option.None,
    decode.optional(
      decode.then(decode.string, fn(s) {
        decode.success(bit_array.from_string(s))
      }),
    ),
  )
  use fail_on_warnings <- decode.optional_field(
    "failOnWarnings",
    option.None,
    decode.optional(decode.bool),
  )
  use mode <- decode.optional_field(
    "mode",
    option.None,
    decode.optional(decode_put_mode_enum()),
  )
  use parameters <- decode.optional_field(
    "parameters",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(PutRestApiRequest(
    body: body,
    fail_on_warnings: fail_on_warnings,
    mode: mode,
    parameters: parameters,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_put_rest_api_request_struct_params() -> decode.Decoder(
  PutRestApiRequest,
) {
  use <- decode.recursive
  use body <- decode.optional_field(
    "body",
    option.None,
    decode.optional(
      decode.then(decode.string, fn(s) {
        decode.success(bit_array.from_string(s))
      }),
    ),
  )
  use fail_on_warnings <- decode.optional_field(
    "failOnWarnings",
    option.None,
    decode.optional(decode.bool),
  )
  use mode <- decode.optional_field(
    "mode",
    option.None,
    decode.optional(decode_put_mode_enum()),
  )
  use parameters <- decode.optional_field(
    "parameters",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(PutRestApiRequest(
    body: body,
    fail_on_warnings: fail_on_warnings,
    mode: mode,
    parameters: parameters,
    rest_api_id: rest_api_id,
  ))
}

pub type RejectDomainNameAccessAssociationRequest {
  RejectDomainNameAccessAssociationRequest(
    domain_name_access_association_arn: option.Option(String),
    domain_name_arn: option.Option(String),
  )
}

pub fn encode_reject_domain_name_access_association_request_struct(
  input: RejectDomainNameAccessAssociationRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.domain_name_access_association_arn {
    option.Some(v) -> [
      #("domainNameAccessAssociationArn", json.string(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.domain_name_arn {
    option.Some(v) -> [#("domainNameArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_reject_domain_name_access_association_request_struct() -> decode.Decoder(
  RejectDomainNameAccessAssociationRequest,
) {
  use <- decode.recursive
  use domain_name_access_association_arn <- decode.optional_field(
    "domainNameAccessAssociationArn",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name_arn <- decode.optional_field(
    "domainNameArn",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(RejectDomainNameAccessAssociationRequest(
    domain_name_access_association_arn: domain_name_access_association_arn,
    domain_name_arn: domain_name_arn,
  ))
}

pub fn decode_reject_domain_name_access_association_request_struct_params() -> decode.Decoder(
  RejectDomainNameAccessAssociationRequest,
) {
  use <- decode.recursive
  use domain_name_access_association_arn <- decode.optional_field(
    "domainNameAccessAssociationArn",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name_arn <- decode.optional_field(
    "domainNameArn",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(RejectDomainNameAccessAssociationRequest(
    domain_name_access_association_arn: domain_name_access_association_arn,
    domain_name_arn: domain_name_arn,
  ))
}

pub type TagResourceRequest {
  TagResourceRequest(
    resource_arn: option.Option(String),
    tags: option.Option(dict.Dict(String, String)),
  )
}

pub fn encode_tag_resource_request_struct(
  input: TagResourceRequest,
) -> 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(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_tag_resource_request_struct() -> decode.Decoder(
  TagResourceRequest,
) {
  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.dict(decode.string, decode.string)),
  )
  decode.success(TagResourceRequest(resource_arn: resource_arn, tags: tags))
}

pub fn decode_tag_resource_request_struct_params() -> decode.Decoder(
  TagResourceRequest,
) {
  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.dict(decode.string, decode.string)),
  )
  decode.success(TagResourceRequest(resource_arn: resource_arn, tags: tags))
}

pub type TestInvokeAuthorizerRequest {
  TestInvokeAuthorizerRequest(
    additional_context: option.Option(dict.Dict(String, String)),
    authorizer_id: option.Option(String),
    body: option.Option(String),
    headers: option.Option(dict.Dict(String, String)),
    multi_value_headers: option.Option(dict.Dict(String, List(String))),
    path_with_query_string: option.Option(String),
    rest_api_id: option.Option(String),
    stage_variables: option.Option(dict.Dict(String, String)),
  )
}

pub fn encode_test_invoke_authorizer_request_struct(
  input: TestInvokeAuthorizerRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.additional_context {
    option.Some(v) -> [
      #(
        "additionalContext",
        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.authorizer_id {
    option.Some(v) -> [#("authorizerId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.body {
    option.Some(v) -> [#("body", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.headers {
    option.Some(v) -> [
      #(
        "headers",
        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.multi_value_headers {
    option.Some(v) -> [
      #(
        "multiValueHeaders",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, fn(xs) { json.array(xs, json.string) }(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.path_with_query_string {
    option.Some(v) -> [#("pathWithQueryString", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.stage_variables {
    option.Some(v) -> [
      #(
        "stageVariables",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_test_invoke_authorizer_request_struct() -> decode.Decoder(
  TestInvokeAuthorizerRequest,
) {
  use <- decode.recursive
  use additional_context <- decode.optional_field(
    "additionalContext",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use authorizer_id <- decode.optional_field(
    "authorizerId",
    option.None,
    decode.optional(decode.string),
  )
  use body <- decode.optional_field(
    "body",
    option.None,
    decode.optional(decode.string),
  )
  use headers <- decode.optional_field(
    "headers",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use multi_value_headers <- decode.optional_field(
    "multiValueHeaders",
    option.None,
    decode.optional(decode.dict(decode.string, decode.list(decode.string))),
  )
  use path_with_query_string <- decode.optional_field(
    "pathWithQueryString",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use stage_variables <- decode.optional_field(
    "stageVariables",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  decode.success(TestInvokeAuthorizerRequest(
    additional_context: additional_context,
    authorizer_id: authorizer_id,
    body: body,
    headers: headers,
    multi_value_headers: multi_value_headers,
    path_with_query_string: path_with_query_string,
    rest_api_id: rest_api_id,
    stage_variables: stage_variables,
  ))
}

pub fn decode_test_invoke_authorizer_request_struct_params() -> decode.Decoder(
  TestInvokeAuthorizerRequest,
) {
  use <- decode.recursive
  use additional_context <- decode.optional_field(
    "additionalContext",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use authorizer_id <- decode.optional_field(
    "authorizerId",
    option.None,
    decode.optional(decode.string),
  )
  use body <- decode.optional_field(
    "body",
    option.None,
    decode.optional(decode.string),
  )
  use headers <- decode.optional_field(
    "headers",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use multi_value_headers <- decode.optional_field(
    "multiValueHeaders",
    option.None,
    decode.optional(decode.dict(decode.string, decode.list(decode.string))),
  )
  use path_with_query_string <- decode.optional_field(
    "pathWithQueryString",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use stage_variables <- decode.optional_field(
    "stageVariables",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  decode.success(TestInvokeAuthorizerRequest(
    additional_context: additional_context,
    authorizer_id: authorizer_id,
    body: body,
    headers: headers,
    multi_value_headers: multi_value_headers,
    path_with_query_string: path_with_query_string,
    rest_api_id: rest_api_id,
    stage_variables: stage_variables,
  ))
}

pub type TestInvokeAuthorizerResponse {
  TestInvokeAuthorizerResponse(
    authorization: option.Option(dict.Dict(String, List(String))),
    claims: option.Option(dict.Dict(String, String)),
    client_status: option.Option(Int),
    latency: option.Option(Int),
    log: option.Option(String),
    policy: option.Option(String),
    principal_id: option.Option(String),
  )
}

pub fn encode_test_invoke_authorizer_response_struct(
  input: TestInvokeAuthorizerResponse,
) -> json.Json {
  let pairs = []
  let pairs = case input.authorization {
    option.Some(v) -> [
      #(
        "authorization",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, fn(xs) { json.array(xs, json.string) }(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.claims {
    option.Some(v) -> [
      #(
        "claims",
        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.client_status {
    option.Some(v) -> [#("clientStatus", json.int(v)), ..pairs]
    option.None -> [#("clientStatus", json.int(0)), ..pairs]
  }
  let pairs = case input.latency {
    option.Some(v) -> [#("latency", json.int(v)), ..pairs]
    option.None -> [#("latency", json.int(0)), ..pairs]
  }
  let pairs = case input.log {
    option.Some(v) -> [#("log", 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.principal_id {
    option.Some(v) -> [#("principalId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_test_invoke_authorizer_response_struct() -> decode.Decoder(
  TestInvokeAuthorizerResponse,
) {
  use <- decode.recursive
  use authorization <- decode.optional_field(
    "authorization",
    option.None,
    decode.optional(decode.dict(decode.string, decode.list(decode.string))),
  )
  use claims <- decode.optional_field(
    "claims",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use client_status <- decode.optional_field(
    "clientStatus",
    option.None,
    decode.optional(decode.int),
  )
  use latency <- decode.optional_field(
    "latency",
    option.None,
    decode.optional(decode.int),
  )
  use log <- decode.optional_field(
    "log",
    option.None,
    decode.optional(decode.string),
  )
  use policy <- decode.optional_field(
    "policy",
    option.None,
    decode.optional(decode.string),
  )
  use principal_id <- decode.optional_field(
    "principalId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(TestInvokeAuthorizerResponse(
    authorization: authorization,
    claims: claims,
    client_status: client_status,
    latency: latency,
    log: log,
    policy: policy,
    principal_id: principal_id,
  ))
}

pub fn decode_test_invoke_authorizer_response_struct_params() -> decode.Decoder(
  TestInvokeAuthorizerResponse,
) {
  use <- decode.recursive
  use authorization <- decode.optional_field(
    "authorization",
    option.None,
    decode.optional(decode.dict(decode.string, decode.list(decode.string))),
  )
  use claims <- decode.optional_field(
    "claims",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use client_status <- decode.optional_field(
    "clientStatus",
    option.None,
    decode.optional(decode.int),
  )
  use latency <- decode.optional_field(
    "latency",
    option.None,
    decode.optional(decode.int),
  )
  use log <- decode.optional_field(
    "log",
    option.None,
    decode.optional(decode.string),
  )
  use policy <- decode.optional_field(
    "policy",
    option.None,
    decode.optional(decode.string),
  )
  use principal_id <- decode.optional_field(
    "principalId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(TestInvokeAuthorizerResponse(
    authorization: authorization,
    claims: claims,
    client_status: client_status,
    latency: latency,
    log: log,
    policy: policy,
    principal_id: principal_id,
  ))
}

pub type TestInvokeMethodRequest {
  TestInvokeMethodRequest(
    body: option.Option(String),
    client_certificate_id: option.Option(String),
    headers: option.Option(dict.Dict(String, String)),
    http_method: option.Option(String),
    multi_value_headers: option.Option(dict.Dict(String, List(String))),
    path_with_query_string: option.Option(String),
    resource_id: option.Option(String),
    rest_api_id: option.Option(String),
    stage_variables: option.Option(dict.Dict(String, String)),
  )
}

pub fn encode_test_invoke_method_request_struct(
  input: TestInvokeMethodRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.body {
    option.Some(v) -> [#("body", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.client_certificate_id {
    option.Some(v) -> [#("clientCertificateId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.headers {
    option.Some(v) -> [
      #(
        "headers",
        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.http_method {
    option.Some(v) -> [#("httpMethod", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.multi_value_headers {
    option.Some(v) -> [
      #(
        "multiValueHeaders",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, fn(xs) { json.array(xs, json.string) }(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.path_with_query_string {
    option.Some(v) -> [#("pathWithQueryString", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.resource_id {
    option.Some(v) -> [#("resourceId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.stage_variables {
    option.Some(v) -> [
      #(
        "stageVariables",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_test_invoke_method_request_struct() -> decode.Decoder(
  TestInvokeMethodRequest,
) {
  use <- decode.recursive
  use body <- decode.optional_field(
    "body",
    option.None,
    decode.optional(decode.string),
  )
  use client_certificate_id <- decode.optional_field(
    "clientCertificateId",
    option.None,
    decode.optional(decode.string),
  )
  use headers <- decode.optional_field(
    "headers",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use multi_value_headers <- decode.optional_field(
    "multiValueHeaders",
    option.None,
    decode.optional(decode.dict(decode.string, decode.list(decode.string))),
  )
  use path_with_query_string <- decode.optional_field(
    "pathWithQueryString",
    option.None,
    decode.optional(decode.string),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use stage_variables <- decode.optional_field(
    "stageVariables",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  decode.success(TestInvokeMethodRequest(
    body: body,
    client_certificate_id: client_certificate_id,
    headers: headers,
    http_method: http_method,
    multi_value_headers: multi_value_headers,
    path_with_query_string: path_with_query_string,
    resource_id: resource_id,
    rest_api_id: rest_api_id,
    stage_variables: stage_variables,
  ))
}

pub fn decode_test_invoke_method_request_struct_params() -> decode.Decoder(
  TestInvokeMethodRequest,
) {
  use <- decode.recursive
  use body <- decode.optional_field(
    "body",
    option.None,
    decode.optional(decode.string),
  )
  use client_certificate_id <- decode.optional_field(
    "clientCertificateId",
    option.None,
    decode.optional(decode.string),
  )
  use headers <- decode.optional_field(
    "headers",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use multi_value_headers <- decode.optional_field(
    "multiValueHeaders",
    option.None,
    decode.optional(decode.dict(decode.string, decode.list(decode.string))),
  )
  use path_with_query_string <- decode.optional_field(
    "pathWithQueryString",
    option.None,
    decode.optional(decode.string),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use stage_variables <- decode.optional_field(
    "stageVariables",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  decode.success(TestInvokeMethodRequest(
    body: body,
    client_certificate_id: client_certificate_id,
    headers: headers,
    http_method: http_method,
    multi_value_headers: multi_value_headers,
    path_with_query_string: path_with_query_string,
    resource_id: resource_id,
    rest_api_id: rest_api_id,
    stage_variables: stage_variables,
  ))
}

pub type TestInvokeMethodResponse {
  TestInvokeMethodResponse(
    body: option.Option(String),
    headers: option.Option(dict.Dict(String, String)),
    latency: option.Option(Int),
    log: option.Option(String),
    multi_value_headers: option.Option(dict.Dict(String, List(String))),
    status: option.Option(Int),
  )
}

pub fn encode_test_invoke_method_response_struct(
  input: TestInvokeMethodResponse,
) -> json.Json {
  let pairs = []
  let pairs = case input.body {
    option.Some(v) -> [#("body", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.headers {
    option.Some(v) -> [
      #(
        "headers",
        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.latency {
    option.Some(v) -> [#("latency", json.int(v)), ..pairs]
    option.None -> [#("latency", json.int(0)), ..pairs]
  }
  let pairs = case input.log {
    option.Some(v) -> [#("log", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.multi_value_headers {
    option.Some(v) -> [
      #(
        "multiValueHeaders",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, fn(xs) { json.array(xs, json.string) }(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.status {
    option.Some(v) -> [#("status", json.int(v)), ..pairs]
    option.None -> [#("status", json.int(0)), ..pairs]
  }
  json.object(pairs)
}

pub fn decode_test_invoke_method_response_struct() -> decode.Decoder(
  TestInvokeMethodResponse,
) {
  use <- decode.recursive
  use body <- decode.optional_field(
    "body",
    option.None,
    decode.optional(decode.string),
  )
  use headers <- decode.optional_field(
    "headers",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use latency <- decode.optional_field(
    "latency",
    option.None,
    decode.optional(decode.int),
  )
  use log <- decode.optional_field(
    "log",
    option.None,
    decode.optional(decode.string),
  )
  use multi_value_headers <- decode.optional_field(
    "multiValueHeaders",
    option.None,
    decode.optional(decode.dict(decode.string, decode.list(decode.string))),
  )
  use status <- decode.optional_field(
    "status",
    option.None,
    decode.optional(decode.int),
  )
  decode.success(TestInvokeMethodResponse(
    body: body,
    headers: headers,
    latency: latency,
    log: log,
    multi_value_headers: multi_value_headers,
    status: status,
  ))
}

pub fn decode_test_invoke_method_response_struct_params() -> decode.Decoder(
  TestInvokeMethodResponse,
) {
  use <- decode.recursive
  use body <- decode.optional_field(
    "body",
    option.None,
    decode.optional(decode.string),
  )
  use headers <- decode.optional_field(
    "headers",
    option.None,
    decode.optional(decode.dict(decode.string, decode.string)),
  )
  use latency <- decode.optional_field(
    "latency",
    option.None,
    decode.optional(decode.int),
  )
  use log <- decode.optional_field(
    "log",
    option.None,
    decode.optional(decode.string),
  )
  use multi_value_headers <- decode.optional_field(
    "multiValueHeaders",
    option.None,
    decode.optional(decode.dict(decode.string, decode.list(decode.string))),
  )
  use status <- decode.optional_field(
    "status",
    option.None,
    decode.optional(decode.int),
  )
  decode.success(TestInvokeMethodResponse(
    body: body,
    headers: headers,
    latency: latency,
    log: log,
    multi_value_headers: multi_value_headers,
    status: status,
  ))
}

pub type UntagResourceRequest {
  UntagResourceRequest(
    resource_arn: option.Option(String),
    tag_keys: option.Option(List(String)),
  )
}

pub fn encode_untag_resource_request_struct(
  input: UntagResourceRequest,
) -> 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_request_struct() -> decode.Decoder(
  UntagResourceRequest,
) {
  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(UntagResourceRequest(
    resource_arn: resource_arn,
    tag_keys: tag_keys,
  ))
}

pub fn decode_untag_resource_request_struct_params() -> decode.Decoder(
  UntagResourceRequest,
) {
  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(UntagResourceRequest(
    resource_arn: resource_arn,
    tag_keys: tag_keys,
  ))
}

pub type UpdateAccountRequest {
  UpdateAccountRequest(patch_operations: option.Option(List(PatchOperation)))
}

pub fn encode_update_account_request_struct(
  input: UpdateAccountRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_account_request_struct() -> decode.Decoder(
  UpdateAccountRequest,
) {
  use <- decode.recursive
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct())),
  )
  decode.success(UpdateAccountRequest(patch_operations: patch_operations))
}

pub fn decode_update_account_request_struct_params() -> decode.Decoder(
  UpdateAccountRequest,
) {
  use <- decode.recursive
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct_params())),
  )
  decode.success(UpdateAccountRequest(patch_operations: patch_operations))
}

pub type PatchOperation {
  PatchOperation(
    from: option.Option(String),
    op: option.Option(Op),
    path: option.Option(String),
    value: option.Option(String),
  )
}

pub fn encode_patch_operation_struct(input: PatchOperation) -> json.Json {
  let pairs = []
  let pairs = case input.from {
    option.Some(v) -> [#("from", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.op {
    option.Some(v) -> [#("op", encode_op_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.path {
    option.Some(v) -> [#("path", 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_patch_operation_struct() -> decode.Decoder(PatchOperation) {
  use <- decode.recursive
  use from <- decode.optional_field(
    "from",
    option.None,
    decode.optional(decode.string),
  )
  use op <- decode.optional_field(
    "op",
    option.None,
    decode.optional(decode_op_enum()),
  )
  use path <- decode.optional_field(
    "path",
    option.None,
    decode.optional(decode.string),
  )
  use value <- decode.optional_field(
    "value",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(PatchOperation(from: from, op: op, path: path, value: value))
}

pub fn decode_patch_operation_struct_params() -> decode.Decoder(PatchOperation) {
  use <- decode.recursive
  use from <- decode.optional_field(
    "from",
    option.None,
    decode.optional(decode.string),
  )
  use op <- decode.optional_field(
    "op",
    option.None,
    decode.optional(decode_op_enum()),
  )
  use path <- decode.optional_field(
    "path",
    option.None,
    decode.optional(decode.string),
  )
  use value <- decode.optional_field(
    "value",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(PatchOperation(from: from, op: op, path: path, value: value))
}

pub type Op {
  OpAdd
  OpCopy
  OpMove
  OpRemove
  OpReplace
  OpTest
}

pub fn encode_op_enum(v: Op) -> json.Json {
  case v {
    OpAdd -> json.string("add")
    OpCopy -> json.string("copy")
    OpMove -> json.string("move")
    OpRemove -> json.string("remove")
    OpReplace -> json.string("replace")
    OpTest -> json.string("test")
  }
}

pub fn decode_op_enum() -> decode.Decoder(Op) {
  decode.then(decode.string, fn(s) {
    case s {
      "add" -> decode.success(OpAdd)
      "copy" -> decode.success(OpCopy)
      "move" -> decode.success(OpMove)
      "remove" -> decode.success(OpRemove)
      "replace" -> decode.success(OpReplace)
      "test" -> decode.success(OpTest)
      _ -> decode.failure(OpAdd, "unknown enum value")
    }
  })
}

pub fn op_from_wire(s: String) -> Result(Op, String) {
  case s {
    "add" -> Ok(OpAdd)
    "copy" -> Ok(OpCopy)
    "move" -> Ok(OpMove)
    "remove" -> Ok(OpRemove)
    "replace" -> Ok(OpReplace)
    "test" -> Ok(OpTest)
    _ -> Ok(OpAdd)
  }
}

pub type UpdateApiKeyRequest {
  UpdateApiKeyRequest(
    api_key: option.Option(String),
    patch_operations: option.Option(List(PatchOperation)),
  )
}

pub fn encode_update_api_key_request_struct(
  input: UpdateApiKeyRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.api_key {
    option.Some(v) -> [#("apiKey", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_api_key_request_struct() -> decode.Decoder(
  UpdateApiKeyRequest,
) {
  use <- decode.recursive
  use api_key <- decode.optional_field(
    "apiKey",
    option.None,
    decode.optional(decode.string),
  )
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct())),
  )
  decode.success(UpdateApiKeyRequest(
    api_key: api_key,
    patch_operations: patch_operations,
  ))
}

pub fn decode_update_api_key_request_struct_params() -> decode.Decoder(
  UpdateApiKeyRequest,
) {
  use <- decode.recursive
  use api_key <- decode.optional_field(
    "apiKey",
    option.None,
    decode.optional(decode.string),
  )
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct_params())),
  )
  decode.success(UpdateApiKeyRequest(
    api_key: api_key,
    patch_operations: patch_operations,
  ))
}

pub type UpdateAuthorizerRequest {
  UpdateAuthorizerRequest(
    authorizer_id: option.Option(String),
    patch_operations: option.Option(List(PatchOperation)),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_update_authorizer_request_struct(
  input: UpdateAuthorizerRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.authorizer_id {
    option.Some(v) -> [#("authorizerId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_authorizer_request_struct() -> decode.Decoder(
  UpdateAuthorizerRequest,
) {
  use <- decode.recursive
  use authorizer_id <- decode.optional_field(
    "authorizerId",
    option.None,
    decode.optional(decode.string),
  )
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct())),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateAuthorizerRequest(
    authorizer_id: authorizer_id,
    patch_operations: patch_operations,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_update_authorizer_request_struct_params() -> decode.Decoder(
  UpdateAuthorizerRequest,
) {
  use <- decode.recursive
  use authorizer_id <- decode.optional_field(
    "authorizerId",
    option.None,
    decode.optional(decode.string),
  )
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct_params())),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateAuthorizerRequest(
    authorizer_id: authorizer_id,
    patch_operations: patch_operations,
    rest_api_id: rest_api_id,
  ))
}

pub type UpdateBasePathMappingRequest {
  UpdateBasePathMappingRequest(
    base_path: option.Option(String),
    domain_name: option.Option(String),
    domain_name_id: option.Option(String),
    patch_operations: option.Option(List(PatchOperation)),
  )
}

pub fn encode_update_base_path_mapping_request_struct(
  input: UpdateBasePathMappingRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.base_path {
    option.Some(v) -> [#("basePath", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.domain_name {
    option.Some(v) -> [#("domainName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.domain_name_id {
    option.Some(v) -> [#("domainNameId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_base_path_mapping_request_struct() -> decode.Decoder(
  UpdateBasePathMappingRequest,
) {
  use <- decode.recursive
  use base_path <- decode.optional_field(
    "basePath",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name <- decode.optional_field(
    "domainName",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name_id <- decode.optional_field(
    "domainNameId",
    option.None,
    decode.optional(decode.string),
  )
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct())),
  )
  decode.success(UpdateBasePathMappingRequest(
    base_path: base_path,
    domain_name: domain_name,
    domain_name_id: domain_name_id,
    patch_operations: patch_operations,
  ))
}

pub fn decode_update_base_path_mapping_request_struct_params() -> decode.Decoder(
  UpdateBasePathMappingRequest,
) {
  use <- decode.recursive
  use base_path <- decode.optional_field(
    "basePath",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name <- decode.optional_field(
    "domainName",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name_id <- decode.optional_field(
    "domainNameId",
    option.None,
    decode.optional(decode.string),
  )
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct_params())),
  )
  decode.success(UpdateBasePathMappingRequest(
    base_path: base_path,
    domain_name: domain_name,
    domain_name_id: domain_name_id,
    patch_operations: patch_operations,
  ))
}

pub type UpdateClientCertificateRequest {
  UpdateClientCertificateRequest(
    client_certificate_id: option.Option(String),
    patch_operations: option.Option(List(PatchOperation)),
  )
}

pub fn encode_update_client_certificate_request_struct(
  input: UpdateClientCertificateRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.client_certificate_id {
    option.Some(v) -> [#("clientCertificateId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_client_certificate_request_struct() -> decode.Decoder(
  UpdateClientCertificateRequest,
) {
  use <- decode.recursive
  use client_certificate_id <- decode.optional_field(
    "clientCertificateId",
    option.None,
    decode.optional(decode.string),
  )
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct())),
  )
  decode.success(UpdateClientCertificateRequest(
    client_certificate_id: client_certificate_id,
    patch_operations: patch_operations,
  ))
}

pub fn decode_update_client_certificate_request_struct_params() -> decode.Decoder(
  UpdateClientCertificateRequest,
) {
  use <- decode.recursive
  use client_certificate_id <- decode.optional_field(
    "clientCertificateId",
    option.None,
    decode.optional(decode.string),
  )
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct_params())),
  )
  decode.success(UpdateClientCertificateRequest(
    client_certificate_id: client_certificate_id,
    patch_operations: patch_operations,
  ))
}

pub type UpdateDeploymentRequest {
  UpdateDeploymentRequest(
    deployment_id: option.Option(String),
    patch_operations: option.Option(List(PatchOperation)),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_update_deployment_request_struct(
  input: UpdateDeploymentRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.deployment_id {
    option.Some(v) -> [#("deploymentId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_deployment_request_struct() -> decode.Decoder(
  UpdateDeploymentRequest,
) {
  use <- decode.recursive
  use deployment_id <- decode.optional_field(
    "deploymentId",
    option.None,
    decode.optional(decode.string),
  )
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct())),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateDeploymentRequest(
    deployment_id: deployment_id,
    patch_operations: patch_operations,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_update_deployment_request_struct_params() -> decode.Decoder(
  UpdateDeploymentRequest,
) {
  use <- decode.recursive
  use deployment_id <- decode.optional_field(
    "deploymentId",
    option.None,
    decode.optional(decode.string),
  )
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct_params())),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateDeploymentRequest(
    deployment_id: deployment_id,
    patch_operations: patch_operations,
    rest_api_id: rest_api_id,
  ))
}

pub type UpdateDocumentationPartRequest {
  UpdateDocumentationPartRequest(
    documentation_part_id: option.Option(String),
    patch_operations: option.Option(List(PatchOperation)),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_update_documentation_part_request_struct(
  input: UpdateDocumentationPartRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.documentation_part_id {
    option.Some(v) -> [#("documentationPartId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_documentation_part_request_struct() -> decode.Decoder(
  UpdateDocumentationPartRequest,
) {
  use <- decode.recursive
  use documentation_part_id <- decode.optional_field(
    "documentationPartId",
    option.None,
    decode.optional(decode.string),
  )
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct())),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateDocumentationPartRequest(
    documentation_part_id: documentation_part_id,
    patch_operations: patch_operations,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_update_documentation_part_request_struct_params() -> decode.Decoder(
  UpdateDocumentationPartRequest,
) {
  use <- decode.recursive
  use documentation_part_id <- decode.optional_field(
    "documentationPartId",
    option.None,
    decode.optional(decode.string),
  )
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct_params())),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateDocumentationPartRequest(
    documentation_part_id: documentation_part_id,
    patch_operations: patch_operations,
    rest_api_id: rest_api_id,
  ))
}

pub type UpdateDocumentationVersionRequest {
  UpdateDocumentationVersionRequest(
    documentation_version: option.Option(String),
    patch_operations: option.Option(List(PatchOperation)),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_update_documentation_version_request_struct(
  input: UpdateDocumentationVersionRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.documentation_version {
    option.Some(v) -> [#("documentationVersion", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_documentation_version_request_struct() -> decode.Decoder(
  UpdateDocumentationVersionRequest,
) {
  use <- decode.recursive
  use documentation_version <- decode.optional_field(
    "documentationVersion",
    option.None,
    decode.optional(decode.string),
  )
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct())),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateDocumentationVersionRequest(
    documentation_version: documentation_version,
    patch_operations: patch_operations,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_update_documentation_version_request_struct_params() -> decode.Decoder(
  UpdateDocumentationVersionRequest,
) {
  use <- decode.recursive
  use documentation_version <- decode.optional_field(
    "documentationVersion",
    option.None,
    decode.optional(decode.string),
  )
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct_params())),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateDocumentationVersionRequest(
    documentation_version: documentation_version,
    patch_operations: patch_operations,
    rest_api_id: rest_api_id,
  ))
}

pub type UpdateDomainNameRequest {
  UpdateDomainNameRequest(
    domain_name: option.Option(String),
    domain_name_id: option.Option(String),
    patch_operations: option.Option(List(PatchOperation)),
  )
}

pub fn encode_update_domain_name_request_struct(
  input: UpdateDomainNameRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.domain_name {
    option.Some(v) -> [#("domainName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.domain_name_id {
    option.Some(v) -> [#("domainNameId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_domain_name_request_struct() -> decode.Decoder(
  UpdateDomainNameRequest,
) {
  use <- decode.recursive
  use domain_name <- decode.optional_field(
    "domainName",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name_id <- decode.optional_field(
    "domainNameId",
    option.None,
    decode.optional(decode.string),
  )
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct())),
  )
  decode.success(UpdateDomainNameRequest(
    domain_name: domain_name,
    domain_name_id: domain_name_id,
    patch_operations: patch_operations,
  ))
}

pub fn decode_update_domain_name_request_struct_params() -> decode.Decoder(
  UpdateDomainNameRequest,
) {
  use <- decode.recursive
  use domain_name <- decode.optional_field(
    "domainName",
    option.None,
    decode.optional(decode.string),
  )
  use domain_name_id <- decode.optional_field(
    "domainNameId",
    option.None,
    decode.optional(decode.string),
  )
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct_params())),
  )
  decode.success(UpdateDomainNameRequest(
    domain_name: domain_name,
    domain_name_id: domain_name_id,
    patch_operations: patch_operations,
  ))
}

pub type UpdateGatewayResponseRequest {
  UpdateGatewayResponseRequest(
    patch_operations: option.Option(List(PatchOperation)),
    response_type: option.Option(GatewayResponseType),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_update_gateway_response_request_struct(
  input: UpdateGatewayResponseRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.response_type {
    option.Some(v) -> [
      #("responseType", encode_gateway_response_type_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_gateway_response_request_struct() -> decode.Decoder(
  UpdateGatewayResponseRequest,
) {
  use <- decode.recursive
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct())),
  )
  use response_type <- decode.optional_field(
    "responseType",
    option.None,
    decode.optional(decode_gateway_response_type_enum()),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateGatewayResponseRequest(
    patch_operations: patch_operations,
    response_type: response_type,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_update_gateway_response_request_struct_params() -> decode.Decoder(
  UpdateGatewayResponseRequest,
) {
  use <- decode.recursive
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct_params())),
  )
  use response_type <- decode.optional_field(
    "responseType",
    option.None,
    decode.optional(decode_gateway_response_type_enum()),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateGatewayResponseRequest(
    patch_operations: patch_operations,
    response_type: response_type,
    rest_api_id: rest_api_id,
  ))
}

pub type UpdateIntegrationRequest {
  UpdateIntegrationRequest(
    http_method: option.Option(String),
    patch_operations: option.Option(List(PatchOperation)),
    resource_id: option.Option(String),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_update_integration_request_struct(
  input: UpdateIntegrationRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.http_method {
    option.Some(v) -> [#("httpMethod", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.resource_id {
    option.Some(v) -> [#("resourceId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_integration_request_struct() -> decode.Decoder(
  UpdateIntegrationRequest,
) {
  use <- decode.recursive
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct())),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateIntegrationRequest(
    http_method: http_method,
    patch_operations: patch_operations,
    resource_id: resource_id,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_update_integration_request_struct_params() -> decode.Decoder(
  UpdateIntegrationRequest,
) {
  use <- decode.recursive
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct_params())),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateIntegrationRequest(
    http_method: http_method,
    patch_operations: patch_operations,
    resource_id: resource_id,
    rest_api_id: rest_api_id,
  ))
}

pub type UpdateIntegrationResponseRequest {
  UpdateIntegrationResponseRequest(
    http_method: option.Option(String),
    patch_operations: option.Option(List(PatchOperation)),
    resource_id: option.Option(String),
    rest_api_id: option.Option(String),
    status_code: option.Option(String),
  )
}

pub fn encode_update_integration_response_request_struct(
  input: UpdateIntegrationResponseRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.http_method {
    option.Some(v) -> [#("httpMethod", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.resource_id {
    option.Some(v) -> [#("resourceId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.status_code {
    option.Some(v) -> [#("statusCode", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_integration_response_request_struct() -> decode.Decoder(
  UpdateIntegrationResponseRequest,
) {
  use <- decode.recursive
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct())),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use status_code <- decode.optional_field(
    "statusCode",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateIntegrationResponseRequest(
    http_method: http_method,
    patch_operations: patch_operations,
    resource_id: resource_id,
    rest_api_id: rest_api_id,
    status_code: status_code,
  ))
}

pub fn decode_update_integration_response_request_struct_params() -> decode.Decoder(
  UpdateIntegrationResponseRequest,
) {
  use <- decode.recursive
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct_params())),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use status_code <- decode.optional_field(
    "statusCode",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateIntegrationResponseRequest(
    http_method: http_method,
    patch_operations: patch_operations,
    resource_id: resource_id,
    rest_api_id: rest_api_id,
    status_code: status_code,
  ))
}

pub type UpdateMethodRequest {
  UpdateMethodRequest(
    http_method: option.Option(String),
    patch_operations: option.Option(List(PatchOperation)),
    resource_id: option.Option(String),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_update_method_request_struct(
  input: UpdateMethodRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.http_method {
    option.Some(v) -> [#("httpMethod", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.resource_id {
    option.Some(v) -> [#("resourceId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_method_request_struct() -> decode.Decoder(
  UpdateMethodRequest,
) {
  use <- decode.recursive
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct())),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateMethodRequest(
    http_method: http_method,
    patch_operations: patch_operations,
    resource_id: resource_id,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_update_method_request_struct_params() -> decode.Decoder(
  UpdateMethodRequest,
) {
  use <- decode.recursive
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct_params())),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateMethodRequest(
    http_method: http_method,
    patch_operations: patch_operations,
    resource_id: resource_id,
    rest_api_id: rest_api_id,
  ))
}

pub type UpdateMethodResponseRequest {
  UpdateMethodResponseRequest(
    http_method: option.Option(String),
    patch_operations: option.Option(List(PatchOperation)),
    resource_id: option.Option(String),
    rest_api_id: option.Option(String),
    status_code: option.Option(String),
  )
}

pub fn encode_update_method_response_request_struct(
  input: UpdateMethodResponseRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.http_method {
    option.Some(v) -> [#("httpMethod", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.resource_id {
    option.Some(v) -> [#("resourceId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.status_code {
    option.Some(v) -> [#("statusCode", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_method_response_request_struct() -> decode.Decoder(
  UpdateMethodResponseRequest,
) {
  use <- decode.recursive
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct())),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use status_code <- decode.optional_field(
    "statusCode",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateMethodResponseRequest(
    http_method: http_method,
    patch_operations: patch_operations,
    resource_id: resource_id,
    rest_api_id: rest_api_id,
    status_code: status_code,
  ))
}

pub fn decode_update_method_response_request_struct_params() -> decode.Decoder(
  UpdateMethodResponseRequest,
) {
  use <- decode.recursive
  use http_method <- decode.optional_field(
    "httpMethod",
    option.None,
    decode.optional(decode.string),
  )
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct_params())),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use status_code <- decode.optional_field(
    "statusCode",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateMethodResponseRequest(
    http_method: http_method,
    patch_operations: patch_operations,
    resource_id: resource_id,
    rest_api_id: rest_api_id,
    status_code: status_code,
  ))
}

pub type UpdateModelRequest {
  UpdateModelRequest(
    model_name: option.Option(String),
    patch_operations: option.Option(List(PatchOperation)),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_update_model_request_struct(
  input: UpdateModelRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.model_name {
    option.Some(v) -> [#("modelName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_model_request_struct() -> decode.Decoder(
  UpdateModelRequest,
) {
  use <- decode.recursive
  use model_name <- decode.optional_field(
    "modelName",
    option.None,
    decode.optional(decode.string),
  )
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct())),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateModelRequest(
    model_name: model_name,
    patch_operations: patch_operations,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_update_model_request_struct_params() -> decode.Decoder(
  UpdateModelRequest,
) {
  use <- decode.recursive
  use model_name <- decode.optional_field(
    "modelName",
    option.None,
    decode.optional(decode.string),
  )
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct_params())),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateModelRequest(
    model_name: model_name,
    patch_operations: patch_operations,
    rest_api_id: rest_api_id,
  ))
}

pub type UpdateRequestValidatorRequest {
  UpdateRequestValidatorRequest(
    patch_operations: option.Option(List(PatchOperation)),
    request_validator_id: option.Option(String),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_update_request_validator_request_struct(
  input: UpdateRequestValidatorRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.request_validator_id {
    option.Some(v) -> [#("requestValidatorId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_request_validator_request_struct() -> decode.Decoder(
  UpdateRequestValidatorRequest,
) {
  use <- decode.recursive
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct())),
  )
  use request_validator_id <- decode.optional_field(
    "requestValidatorId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateRequestValidatorRequest(
    patch_operations: patch_operations,
    request_validator_id: request_validator_id,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_update_request_validator_request_struct_params() -> decode.Decoder(
  UpdateRequestValidatorRequest,
) {
  use <- decode.recursive
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct_params())),
  )
  use request_validator_id <- decode.optional_field(
    "requestValidatorId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateRequestValidatorRequest(
    patch_operations: patch_operations,
    request_validator_id: request_validator_id,
    rest_api_id: rest_api_id,
  ))
}

pub type UpdateResourceRequest {
  UpdateResourceRequest(
    patch_operations: option.Option(List(PatchOperation)),
    resource_id: option.Option(String),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_update_resource_request_struct(
  input: UpdateResourceRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.resource_id {
    option.Some(v) -> [#("resourceId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_resource_request_struct() -> decode.Decoder(
  UpdateResourceRequest,
) {
  use <- decode.recursive
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct())),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateResourceRequest(
    patch_operations: patch_operations,
    resource_id: resource_id,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_update_resource_request_struct_params() -> decode.Decoder(
  UpdateResourceRequest,
) {
  use <- decode.recursive
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct_params())),
  )
  use resource_id <- decode.optional_field(
    "resourceId",
    option.None,
    decode.optional(decode.string),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateResourceRequest(
    patch_operations: patch_operations,
    resource_id: resource_id,
    rest_api_id: rest_api_id,
  ))
}

pub type UpdateRestApiRequest {
  UpdateRestApiRequest(
    patch_operations: option.Option(List(PatchOperation)),
    rest_api_id: option.Option(String),
  )
}

pub fn encode_update_rest_api_request_struct(
  input: UpdateRestApiRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_rest_api_request_struct() -> decode.Decoder(
  UpdateRestApiRequest,
) {
  use <- decode.recursive
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct())),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateRestApiRequest(
    patch_operations: patch_operations,
    rest_api_id: rest_api_id,
  ))
}

pub fn decode_update_rest_api_request_struct_params() -> decode.Decoder(
  UpdateRestApiRequest,
) {
  use <- decode.recursive
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct_params())),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateRestApiRequest(
    patch_operations: patch_operations,
    rest_api_id: rest_api_id,
  ))
}

pub type UpdateStageRequest {
  UpdateStageRequest(
    patch_operations: option.Option(List(PatchOperation)),
    rest_api_id: option.Option(String),
    stage_name: option.Option(String),
  )
}

pub fn encode_update_stage_request_struct(
  input: UpdateStageRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.stage_name {
    option.Some(v) -> [#("stageName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_stage_request_struct() -> decode.Decoder(
  UpdateStageRequest,
) {
  use <- decode.recursive
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct())),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use stage_name <- decode.optional_field(
    "stageName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateStageRequest(
    patch_operations: patch_operations,
    rest_api_id: rest_api_id,
    stage_name: stage_name,
  ))
}

pub fn decode_update_stage_request_struct_params() -> decode.Decoder(
  UpdateStageRequest,
) {
  use <- decode.recursive
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct_params())),
  )
  use rest_api_id <- decode.optional_field(
    "restApiId",
    option.None,
    decode.optional(decode.string),
  )
  use stage_name <- decode.optional_field(
    "stageName",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateStageRequest(
    patch_operations: patch_operations,
    rest_api_id: rest_api_id,
    stage_name: stage_name,
  ))
}

pub type UpdateUsageRequest {
  UpdateUsageRequest(
    key_id: option.Option(String),
    patch_operations: option.Option(List(PatchOperation)),
    usage_plan_id: option.Option(String),
  )
}

pub fn encode_update_usage_request_struct(
  input: UpdateUsageRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.key_id {
    option.Some(v) -> [#("keyId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.usage_plan_id {
    option.Some(v) -> [#("usagePlanId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_usage_request_struct() -> decode.Decoder(
  UpdateUsageRequest,
) {
  use <- decode.recursive
  use key_id <- decode.optional_field(
    "keyId",
    option.None,
    decode.optional(decode.string),
  )
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct())),
  )
  use usage_plan_id <- decode.optional_field(
    "usagePlanId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateUsageRequest(
    key_id: key_id,
    patch_operations: patch_operations,
    usage_plan_id: usage_plan_id,
  ))
}

pub fn decode_update_usage_request_struct_params() -> decode.Decoder(
  UpdateUsageRequest,
) {
  use <- decode.recursive
  use key_id <- decode.optional_field(
    "keyId",
    option.None,
    decode.optional(decode.string),
  )
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct_params())),
  )
  use usage_plan_id <- decode.optional_field(
    "usagePlanId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateUsageRequest(
    key_id: key_id,
    patch_operations: patch_operations,
    usage_plan_id: usage_plan_id,
  ))
}

pub type UpdateUsagePlanRequest {
  UpdateUsagePlanRequest(
    patch_operations: option.Option(List(PatchOperation)),
    usage_plan_id: option.Option(String),
  )
}

pub fn encode_update_usage_plan_request_struct(
  input: UpdateUsagePlanRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.usage_plan_id {
    option.Some(v) -> [#("usagePlanId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_usage_plan_request_struct() -> decode.Decoder(
  UpdateUsagePlanRequest,
) {
  use <- decode.recursive
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct())),
  )
  use usage_plan_id <- decode.optional_field(
    "usagePlanId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateUsagePlanRequest(
    patch_operations: patch_operations,
    usage_plan_id: usage_plan_id,
  ))
}

pub fn decode_update_usage_plan_request_struct_params() -> decode.Decoder(
  UpdateUsagePlanRequest,
) {
  use <- decode.recursive
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct_params())),
  )
  use usage_plan_id <- decode.optional_field(
    "usagePlanId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateUsagePlanRequest(
    patch_operations: patch_operations,
    usage_plan_id: usage_plan_id,
  ))
}

pub type UpdateVpcLinkRequest {
  UpdateVpcLinkRequest(
    patch_operations: option.Option(List(PatchOperation)),
    vpc_link_id: option.Option(String),
  )
}

pub fn encode_update_vpc_link_request_struct(
  input: UpdateVpcLinkRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.vpc_link_id {
    option.Some(v) -> [#("vpcLinkId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn decode_update_vpc_link_request_struct() -> decode.Decoder(
  UpdateVpcLinkRequest,
) {
  use <- decode.recursive
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct())),
  )
  use vpc_link_id <- decode.optional_field(
    "vpcLinkId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateVpcLinkRequest(
    patch_operations: patch_operations,
    vpc_link_id: vpc_link_id,
  ))
}

pub fn decode_update_vpc_link_request_struct_params() -> decode.Decoder(
  UpdateVpcLinkRequest,
) {
  use <- decode.recursive
  use patch_operations <- decode.optional_field(
    "patchOperations",
    option.None,
    decode.optional(decode.list(decode_patch_operation_struct_params())),
  )
  use vpc_link_id <- decode.optional_field(
    "vpcLinkId",
    option.None,
    decode.optional(decode.string),
  )
  decode.success(UpdateVpcLinkRequest(
    patch_operations: patch_operations,
    vpc_link_id: vpc_link_id,
  ))
}

pub fn encode_create_api_key_input(input: CreateApiKeyRequest) -> String {
  json.to_string(encode_create_api_key_request_struct(input))
}

pub fn decode_create_api_key_input(
  body: String,
) -> Result(CreateApiKeyRequest, String) {
  case json.parse(body, decode_create_api_key_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_create_api_key_output(body: String) -> Result(ApiKey, String) {
  case json.parse(body, decode_api_key_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_create_api_key_body(input: CreateApiKeyRequest) -> json.Json {
  let pairs = []
  let pairs = case input.customer_id {
    option.Some(v) -> [#("customerId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.description {
    option.Some(v) -> [#("description", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.enabled {
    option.Some(v) -> [#("enabled", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.generate_distinct_id {
    option.Some(v) -> [#("generateDistinctId", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.name {
    option.Some(v) -> [#("name", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.stage_keys {
    option.Some(v) -> [
      #("stageKeys", fn(xs) { json.array(xs, encode_stage_key_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.tags {
    option.Some(v) -> [
      #(
        "tags",
        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.value {
    option.Some(v) -> [#("value", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_create_api_key_request(
  input: CreateApiKeyRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/apikeys"
  let query = ""
  let headers = dict.new()
  let body_json = encode_create_api_key_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("POST", path, headers, body)
}

pub fn parse_create_api_key_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(ApiKey, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_create_api_key_output("{}")
        _ -> decode_create_api_key_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_create_authorizer_input(
  input: CreateAuthorizerRequest,
) -> String {
  json.to_string(encode_create_authorizer_request_struct(input))
}

pub fn decode_create_authorizer_input(
  body: String,
) -> Result(CreateAuthorizerRequest, String) {
  case json.parse(body, decode_create_authorizer_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_create_authorizer_output(
  body: String,
) -> Result(Authorizer, String) {
  case json.parse(body, decode_authorizer_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_create_authorizer_body(
  input: CreateAuthorizerRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.auth_type {
    option.Some(v) -> [#("authType", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.authorizer_credentials {
    option.Some(v) -> [#("authorizerCredentials", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.authorizer_result_ttl_in_seconds {
    option.Some(v) -> [#("authorizerResultTtlInSeconds", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.authorizer_uri {
    option.Some(v) -> [#("authorizerUri", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.identity_source {
    option.Some(v) -> [#("identitySource", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.identity_validation_expression {
    option.Some(v) -> [
      #("identityValidationExpression", json.string(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.name {
    option.Some(v) -> [#("name", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.provider_ar_ns {
    option.Some(v) -> [
      #("providerARNs", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.type_ {
    option.Some(v) -> [#("type", encode_authorizer_type_enum(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_create_authorizer_request(
  input: CreateAuthorizerRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/authorizers"
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body_json = encode_create_authorizer_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("POST", path, headers, body)
}

pub fn parse_create_authorizer_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Authorizer, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_create_authorizer_output("{}")
        _ -> decode_create_authorizer_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_create_base_path_mapping_input(
  input: CreateBasePathMappingRequest,
) -> String {
  json.to_string(encode_create_base_path_mapping_request_struct(input))
}

pub fn decode_create_base_path_mapping_input(
  body: String,
) -> Result(CreateBasePathMappingRequest, String) {
  case
    json.parse(body, decode_create_base_path_mapping_request_struct_params())
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_create_base_path_mapping_output(
  body: String,
) -> Result(BasePathMapping, String) {
  case json.parse(body, decode_base_path_mapping_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_create_base_path_mapping_body(
  input: CreateBasePathMappingRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.base_path {
    option.Some(v) -> [#("basePath", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.rest_api_id {
    option.Some(v) -> [#("restApiId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.stage {
    option.Some(v) -> [#("stage", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_create_base_path_mapping_request(
  input: CreateBasePathMappingRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/domainnames/{domainName}/basepathmappings"
  let path = case input.domain_name {
    option.Some(v) -> rest.substitute_label(path, "domainName", v, False)
    option.None -> path
  }
  let query = ""
  let query = case input.domain_name_id {
    option.Some(v) -> rest.add_query(query, "domainNameId", v)
    option.None -> query
  }
  let headers = dict.new()
  let body_json = encode_create_base_path_mapping_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("POST", path, headers, body)
}

pub fn parse_create_base_path_mapping_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(BasePathMapping, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_create_base_path_mapping_output("{}")
        _ -> decode_create_base_path_mapping_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_create_deployment_input(
  input: CreateDeploymentRequest,
) -> String {
  json.to_string(encode_create_deployment_request_struct(input))
}

pub fn decode_create_deployment_input(
  body: String,
) -> Result(CreateDeploymentRequest, String) {
  case json.parse(body, decode_create_deployment_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_create_deployment_output(
  body: String,
) -> Result(Deployment, String) {
  case json.parse(body, decode_deployment_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_create_deployment_body(
  input: CreateDeploymentRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.cache_cluster_enabled {
    option.Some(v) -> [#("cacheClusterEnabled", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.cache_cluster_size {
    option.Some(v) -> [
      #("cacheClusterSize", encode_cache_cluster_size_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.canary_settings {
    option.Some(v) -> [
      #("canarySettings", encode_deployment_canary_settings_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.description {
    option.Some(v) -> [#("description", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.stage_description {
    option.Some(v) -> [#("stageDescription", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.stage_name {
    option.Some(v) -> [#("stageName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.tracing_enabled {
    option.Some(v) -> [#("tracingEnabled", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.variables {
    option.Some(v) -> [
      #(
        "variables",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_create_deployment_request(
  input: CreateDeploymentRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/deployments"
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body_json = encode_create_deployment_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("POST", path, headers, body)
}

pub fn parse_create_deployment_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Deployment, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_create_deployment_output("{}")
        _ -> decode_create_deployment_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_create_documentation_part_input(
  input: CreateDocumentationPartRequest,
) -> String {
  json.to_string(encode_create_documentation_part_request_struct(input))
}

pub fn decode_create_documentation_part_input(
  body: String,
) -> Result(CreateDocumentationPartRequest, String) {
  case
    json.parse(body, decode_create_documentation_part_request_struct_params())
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_create_documentation_part_output(
  body: String,
) -> Result(DocumentationPart, String) {
  case json.parse(body, decode_documentation_part_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_create_documentation_part_body(
  input: CreateDocumentationPartRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.location {
    option.Some(v) -> [
      #("location", encode_documentation_part_location_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.properties {
    option.Some(v) -> [#("properties", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_create_documentation_part_request(
  input: CreateDocumentationPartRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/documentation/parts"
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body_json = encode_create_documentation_part_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("POST", path, headers, body)
}

pub fn parse_create_documentation_part_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(DocumentationPart, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_create_documentation_part_output("{}")
        _ -> decode_create_documentation_part_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_create_documentation_version_input(
  input: CreateDocumentationVersionRequest,
) -> String {
  json.to_string(encode_create_documentation_version_request_struct(input))
}

pub fn decode_create_documentation_version_input(
  body: String,
) -> Result(CreateDocumentationVersionRequest, String) {
  case
    json.parse(
      body,
      decode_create_documentation_version_request_struct_params(),
    )
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_create_documentation_version_output(
  body: String,
) -> Result(DocumentationVersion, String) {
  case json.parse(body, decode_documentation_version_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_create_documentation_version_body(
  input: CreateDocumentationVersionRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.description {
    option.Some(v) -> [#("description", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.documentation_version {
    option.Some(v) -> [#("documentationVersion", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.stage_name {
    option.Some(v) -> [#("stageName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_create_documentation_version_request(
  input: CreateDocumentationVersionRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/documentation/versions"
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body_json = encode_create_documentation_version_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("POST", path, headers, body)
}

pub fn parse_create_documentation_version_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(DocumentationVersion, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_create_documentation_version_output("{}")
        _ -> decode_create_documentation_version_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_create_domain_name_input(
  input: CreateDomainNameRequest,
) -> String {
  json.to_string(encode_create_domain_name_request_struct(input))
}

pub fn decode_create_domain_name_input(
  body: String,
) -> Result(CreateDomainNameRequest, String) {
  case json.parse(body, decode_create_domain_name_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_create_domain_name_output(
  body: String,
) -> Result(DomainName, String) {
  case json.parse(body, decode_domain_name_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_create_domain_name_body(
  input: CreateDomainNameRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.certificate_arn {
    option.Some(v) -> [#("certificateArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.certificate_body {
    option.Some(v) -> [#("certificateBody", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.certificate_chain {
    option.Some(v) -> [#("certificateChain", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.certificate_name {
    option.Some(v) -> [#("certificateName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.certificate_private_key {
    option.Some(v) -> [#("certificatePrivateKey", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.domain_name {
    option.Some(v) -> [#("domainName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.endpoint_access_mode {
    option.Some(v) -> [
      #("endpointAccessMode", encode_endpoint_access_mode_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.endpoint_configuration {
    option.Some(v) -> [
      #("endpointConfiguration", encode_endpoint_configuration_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.mutual_tls_authentication {
    option.Some(v) -> [
      #(
        "mutualTlsAuthentication",
        encode_mutual_tls_authentication_input_struct(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.ownership_verification_certificate_arn {
    option.Some(v) -> [
      #("ownershipVerificationCertificateArn", 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.regional_certificate_arn {
    option.Some(v) -> [#("regionalCertificateArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.regional_certificate_name {
    option.Some(v) -> [#("regionalCertificateName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.routing_mode {
    option.Some(v) -> [#("routingMode", encode_routing_mode_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.security_policy {
    option.Some(v) -> [
      #("securityPolicy", encode_security_policy_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.tags {
    option.Some(v) -> [
      #(
        "tags",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_create_domain_name_request(
  input: CreateDomainNameRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/domainnames"
  let query = ""
  let headers = dict.new()
  let body_json = encode_create_domain_name_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("POST", path, headers, body)
}

pub fn parse_create_domain_name_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(DomainName, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_create_domain_name_output("{}")
        _ -> decode_create_domain_name_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_create_domain_name_access_association_input(
  input: CreateDomainNameAccessAssociationRequest,
) -> String {
  json.to_string(encode_create_domain_name_access_association_request_struct(
    input,
  ))
}

pub fn decode_create_domain_name_access_association_input(
  body: String,
) -> Result(CreateDomainNameAccessAssociationRequest, String) {
  case
    json.parse(
      body,
      decode_create_domain_name_access_association_request_struct_params(),
    )
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_create_domain_name_access_association_output(
  body: String,
) -> Result(DomainNameAccessAssociation, String) {
  case json.parse(body, decode_domain_name_access_association_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_create_domain_name_access_association_body(
  input: CreateDomainNameAccessAssociationRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.access_association_source {
    option.Some(v) -> [#("accessAssociationSource", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.access_association_source_type {
    option.Some(v) -> [
      #(
        "accessAssociationSourceType",
        encode_access_association_source_type_enum(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.domain_name_arn {
    option.Some(v) -> [#("domainNameArn", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.tags {
    option.Some(v) -> [
      #(
        "tags",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_create_domain_name_access_association_request(
  input: CreateDomainNameAccessAssociationRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/domainnameaccessassociations"
  let query = ""
  let headers = dict.new()
  let body_json = encode_create_domain_name_access_association_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("POST", path, headers, body)
}

pub fn parse_create_domain_name_access_association_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(DomainNameAccessAssociation, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_create_domain_name_access_association_output("{}")
        _ -> decode_create_domain_name_access_association_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_create_model_input(input: CreateModelRequest) -> String {
  json.to_string(encode_create_model_request_struct(input))
}

pub fn decode_create_model_input(
  body: String,
) -> Result(CreateModelRequest, String) {
  case json.parse(body, decode_create_model_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_create_model_output(body: String) -> Result(Model, String) {
  case json.parse(body, decode_model_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_create_model_body(input: CreateModelRequest) -> json.Json {
  let pairs = []
  let pairs = case input.content_type {
    option.Some(v) -> [#("contentType", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.description {
    option.Some(v) -> [#("description", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.name {
    option.Some(v) -> [#("name", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.schema {
    option.Some(v) -> [#("schema", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_create_model_request(
  input: CreateModelRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/models"
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body_json = encode_create_model_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("POST", path, headers, body)
}

pub fn parse_create_model_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Model, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_create_model_output("{}")
        _ -> decode_create_model_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_create_request_validator_input(
  input: CreateRequestValidatorRequest,
) -> String {
  json.to_string(encode_create_request_validator_request_struct(input))
}

pub fn decode_create_request_validator_input(
  body: String,
) -> Result(CreateRequestValidatorRequest, String) {
  case
    json.parse(body, decode_create_request_validator_request_struct_params())
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_create_request_validator_output(
  body: String,
) -> Result(RequestValidator, String) {
  case json.parse(body, decode_request_validator_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_create_request_validator_body(
  input: CreateRequestValidatorRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.name {
    option.Some(v) -> [#("name", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.validate_request_body {
    option.Some(v) -> [#("validateRequestBody", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.validate_request_parameters {
    option.Some(v) -> [#("validateRequestParameters", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_create_request_validator_request(
  input: CreateRequestValidatorRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/requestvalidators"
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body_json = encode_create_request_validator_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("POST", path, headers, body)
}

pub fn parse_create_request_validator_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(RequestValidator, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_create_request_validator_output("{}")
        _ -> decode_create_request_validator_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_create_resource_input(input: CreateResourceRequest) -> String {
  json.to_string(encode_create_resource_request_struct(input))
}

pub fn decode_create_resource_input(
  body: String,
) -> Result(CreateResourceRequest, String) {
  case json.parse(body, decode_create_resource_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_create_resource_output(body: String) -> Result(Resource, String) {
  case json.parse(body, decode_resource_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

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

pub fn build_create_resource_request(
  input: CreateResourceRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/resources/{parentId}"
  let path = case input.parent_id {
    option.Some(v) -> rest.substitute_label(path, "parentId", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body_json = encode_create_resource_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("POST", path, headers, body)
}

pub fn parse_create_resource_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Resource, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_create_resource_output("{}")
        _ -> decode_create_resource_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_create_rest_api_input(input: CreateRestApiRequest) -> String {
  json.to_string(encode_create_rest_api_request_struct(input))
}

pub fn decode_create_rest_api_input(
  body: String,
) -> Result(CreateRestApiRequest, String) {
  case json.parse(body, decode_create_rest_api_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_create_rest_api_output(body: String) -> Result(RestApi, String) {
  case json.parse(body, decode_rest_api_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_create_rest_api_body(input: CreateRestApiRequest) -> json.Json {
  let pairs = []
  let pairs = case input.api_key_source {
    option.Some(v) -> [
      #("apiKeySource", encode_api_key_source_type_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.binary_media_types {
    option.Some(v) -> [
      #("binaryMediaTypes", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.clone_from {
    option.Some(v) -> [#("cloneFrom", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.description {
    option.Some(v) -> [#("description", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.disable_execute_api_endpoint {
    option.Some(v) -> [#("disableExecuteApiEndpoint", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.endpoint_access_mode {
    option.Some(v) -> [
      #("endpointAccessMode", encode_endpoint_access_mode_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.endpoint_configuration {
    option.Some(v) -> [
      #("endpointConfiguration", encode_endpoint_configuration_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.minimum_compression_size {
    option.Some(v) -> [#("minimumCompressionSize", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.name {
    option.Some(v) -> [#("name", 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.security_policy {
    option.Some(v) -> [
      #("securityPolicy", encode_security_policy_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.tags {
    option.Some(v) -> [
      #(
        "tags",
        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.version {
    option.Some(v) -> [#("version", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_create_rest_api_request(
  input: CreateRestApiRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis"
  let query = ""
  let headers = dict.new()
  let body_json = encode_create_rest_api_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("POST", path, headers, body)
}

pub fn parse_create_rest_api_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(RestApi, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_create_rest_api_output("{}")
        _ -> decode_create_rest_api_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_create_stage_input(input: CreateStageRequest) -> String {
  json.to_string(encode_create_stage_request_struct(input))
}

pub fn decode_create_stage_input(
  body: String,
) -> Result(CreateStageRequest, String) {
  case json.parse(body, decode_create_stage_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_create_stage_output(body: String) -> Result(Stage, String) {
  case json.parse(body, decode_stage_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_create_stage_body(input: CreateStageRequest) -> json.Json {
  let pairs = []
  let pairs = case input.cache_cluster_enabled {
    option.Some(v) -> [#("cacheClusterEnabled", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.cache_cluster_size {
    option.Some(v) -> [
      #("cacheClusterSize", encode_cache_cluster_size_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.canary_settings {
    option.Some(v) -> [
      #("canarySettings", encode_canary_settings_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.deployment_id {
    option.Some(v) -> [#("deploymentId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.description {
    option.Some(v) -> [#("description", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.documentation_version {
    option.Some(v) -> [#("documentationVersion", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.stage_name {
    option.Some(v) -> [#("stageName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.tags {
    option.Some(v) -> [
      #(
        "tags",
        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.tracing_enabled {
    option.Some(v) -> [#("tracingEnabled", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.variables {
    option.Some(v) -> [
      #(
        "variables",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_create_stage_request(
  input: CreateStageRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/stages"
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body_json = encode_create_stage_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("POST", path, headers, body)
}

pub fn parse_create_stage_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Stage, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_create_stage_output("{}")
        _ -> decode_create_stage_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_create_usage_plan_input(input: CreateUsagePlanRequest) -> String {
  json.to_string(encode_create_usage_plan_request_struct(input))
}

pub fn decode_create_usage_plan_input(
  body: String,
) -> Result(CreateUsagePlanRequest, String) {
  case json.parse(body, decode_create_usage_plan_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_create_usage_plan_output(
  body: String,
) -> Result(UsagePlan, String) {
  case json.parse(body, decode_usage_plan_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_create_usage_plan_body(
  input: CreateUsagePlanRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.api_stages {
    option.Some(v) -> [
      #("apiStages", fn(xs) { json.array(xs, encode_api_stage_struct) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.description {
    option.Some(v) -> [#("description", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.name {
    option.Some(v) -> [#("name", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.quota {
    option.Some(v) -> [#("quota", encode_quota_settings_struct(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.tags {
    option.Some(v) -> [
      #(
        "tags",
        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.throttle {
    option.Some(v) -> [
      #("throttle", encode_throttle_settings_struct(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_create_usage_plan_request(
  input: CreateUsagePlanRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/usageplans"
  let query = ""
  let headers = dict.new()
  let body_json = encode_create_usage_plan_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("POST", path, headers, body)
}

pub fn parse_create_usage_plan_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(UsagePlan, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_create_usage_plan_output("{}")
        _ -> decode_create_usage_plan_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_create_usage_plan_key_input(
  input: CreateUsagePlanKeyRequest,
) -> String {
  json.to_string(encode_create_usage_plan_key_request_struct(input))
}

pub fn decode_create_usage_plan_key_input(
  body: String,
) -> Result(CreateUsagePlanKeyRequest, String) {
  case json.parse(body, decode_create_usage_plan_key_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_create_usage_plan_key_output(
  body: String,
) -> Result(UsagePlanKey, String) {
  case json.parse(body, decode_usage_plan_key_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_create_usage_plan_key_body(
  input: CreateUsagePlanKeyRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.key_id {
    option.Some(v) -> [#("keyId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.key_type {
    option.Some(v) -> [#("keyType", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_create_usage_plan_key_request(
  input: CreateUsagePlanKeyRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/usageplans/{usagePlanId}/keys"
  let path = case input.usage_plan_id {
    option.Some(v) -> rest.substitute_label(path, "usagePlanId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body_json = encode_create_usage_plan_key_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("POST", path, headers, body)
}

pub fn parse_create_usage_plan_key_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(UsagePlanKey, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_create_usage_plan_key_output("{}")
        _ -> decode_create_usage_plan_key_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_create_vpc_link_input(input: CreateVpcLinkRequest) -> String {
  json.to_string(encode_create_vpc_link_request_struct(input))
}

pub fn decode_create_vpc_link_input(
  body: String,
) -> Result(CreateVpcLinkRequest, String) {
  case json.parse(body, decode_create_vpc_link_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_create_vpc_link_output(body: String) -> Result(VpcLink, String) {
  case json.parse(body, decode_vpc_link_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_create_vpc_link_body(input: CreateVpcLinkRequest) -> json.Json {
  let pairs = []
  let pairs = case input.description {
    option.Some(v) -> [#("description", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.name {
    option.Some(v) -> [#("name", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.tags {
    option.Some(v) -> [
      #(
        "tags",
        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.target_arns {
    option.Some(v) -> [
      #("targetArns", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_create_vpc_link_request(
  input: CreateVpcLinkRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/vpclinks"
  let query = ""
  let headers = dict.new()
  let body_json = encode_create_vpc_link_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("POST", path, headers, body)
}

pub fn parse_create_vpc_link_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(VpcLink, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_create_vpc_link_output("{}")
        _ -> decode_create_vpc_link_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type DeleteApiKeyOutput {
  DeleteApiKeyOutput
}

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

pub fn decode_delete_api_key_output_struct() -> decode.Decoder(
  DeleteApiKeyOutput,
) {
  decode.success(DeleteApiKeyOutput)
}

pub fn encode_delete_api_key_input(input: DeleteApiKeyRequest) -> String {
  json.to_string(encode_delete_api_key_request_struct(input))
}

pub fn decode_delete_api_key_input(
  body: String,
) -> Result(DeleteApiKeyRequest, String) {
  case json.parse(body, decode_delete_api_key_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_delete_api_key_output(
  body: String,
) -> Result(DeleteApiKeyOutput, String) {
  case json.parse(body, decode_delete_api_key_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_delete_api_key_body(_input: DeleteApiKeyRequest) -> json.Json {
  json.object([])
}

pub fn build_delete_api_key_request(
  input: DeleteApiKeyRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/apikeys/{apiKey}"
  let path = case input.api_key {
    option.Some(v) -> rest.substitute_label(path, "apiKey", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("DELETE", path, headers, body)
}

pub fn parse_delete_api_key_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  _body: BitArray,
) -> Result(DeleteApiKeyOutput, String) {
  Ok(DeleteApiKeyOutput)
}

pub type DeleteAuthorizerOutput {
  DeleteAuthorizerOutput
}

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

pub fn decode_delete_authorizer_output_struct() -> decode.Decoder(
  DeleteAuthorizerOutput,
) {
  decode.success(DeleteAuthorizerOutput)
}

pub fn encode_delete_authorizer_input(
  input: DeleteAuthorizerRequest,
) -> String {
  json.to_string(encode_delete_authorizer_request_struct(input))
}

pub fn decode_delete_authorizer_input(
  body: String,
) -> Result(DeleteAuthorizerRequest, String) {
  case json.parse(body, decode_delete_authorizer_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_delete_authorizer_output(
  body: String,
) -> Result(DeleteAuthorizerOutput, String) {
  case json.parse(body, decode_delete_authorizer_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_delete_authorizer_body(
  _input: DeleteAuthorizerRequest,
) -> json.Json {
  json.object([])
}

pub fn build_delete_authorizer_request(
  input: DeleteAuthorizerRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/authorizers/{authorizerId}"
  let path = case input.authorizer_id {
    option.Some(v) -> rest.substitute_label(path, "authorizerId", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("DELETE", path, headers, body)
}

pub fn parse_delete_authorizer_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  _body: BitArray,
) -> Result(DeleteAuthorizerOutput, String) {
  Ok(DeleteAuthorizerOutput)
}

pub type DeleteBasePathMappingOutput {
  DeleteBasePathMappingOutput
}

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

pub fn decode_delete_base_path_mapping_output_struct() -> decode.Decoder(
  DeleteBasePathMappingOutput,
) {
  decode.success(DeleteBasePathMappingOutput)
}

pub fn encode_delete_base_path_mapping_input(
  input: DeleteBasePathMappingRequest,
) -> String {
  json.to_string(encode_delete_base_path_mapping_request_struct(input))
}

pub fn decode_delete_base_path_mapping_input(
  body: String,
) -> Result(DeleteBasePathMappingRequest, String) {
  case
    json.parse(body, decode_delete_base_path_mapping_request_struct_params())
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_delete_base_path_mapping_output(
  body: String,
) -> Result(DeleteBasePathMappingOutput, String) {
  case json.parse(body, decode_delete_base_path_mapping_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_delete_base_path_mapping_body(
  _input: DeleteBasePathMappingRequest,
) -> json.Json {
  json.object([])
}

pub fn build_delete_base_path_mapping_request(
  input: DeleteBasePathMappingRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/domainnames/{domainName}/basepathmappings/{basePath}"
  let path = case input.base_path {
    option.Some(v) -> rest.substitute_label(path, "basePath", v, False)
    option.None -> path
  }
  let path = case input.domain_name {
    option.Some(v) -> rest.substitute_label(path, "domainName", v, False)
    option.None -> path
  }
  let query = ""
  let query = case input.domain_name_id {
    option.Some(v) -> rest.add_query(query, "domainNameId", v)
    option.None -> query
  }
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("DELETE", path, headers, body)
}

pub fn parse_delete_base_path_mapping_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  _body: BitArray,
) -> Result(DeleteBasePathMappingOutput, String) {
  Ok(DeleteBasePathMappingOutput)
}

pub type DeleteClientCertificateOutput {
  DeleteClientCertificateOutput
}

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

pub fn decode_delete_client_certificate_output_struct() -> decode.Decoder(
  DeleteClientCertificateOutput,
) {
  decode.success(DeleteClientCertificateOutput)
}

pub fn encode_delete_client_certificate_input(
  input: DeleteClientCertificateRequest,
) -> String {
  json.to_string(encode_delete_client_certificate_request_struct(input))
}

pub fn decode_delete_client_certificate_input(
  body: String,
) -> Result(DeleteClientCertificateRequest, String) {
  case
    json.parse(body, decode_delete_client_certificate_request_struct_params())
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_delete_client_certificate_output(
  body: String,
) -> Result(DeleteClientCertificateOutput, String) {
  case json.parse(body, decode_delete_client_certificate_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_delete_client_certificate_body(
  _input: DeleteClientCertificateRequest,
) -> json.Json {
  json.object([])
}

pub fn build_delete_client_certificate_request(
  input: DeleteClientCertificateRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/clientcertificates/{clientCertificateId}"
  let path = case input.client_certificate_id {
    option.Some(v) ->
      rest.substitute_label(path, "clientCertificateId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("DELETE", path, headers, body)
}

pub fn parse_delete_client_certificate_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  _body: BitArray,
) -> Result(DeleteClientCertificateOutput, String) {
  Ok(DeleteClientCertificateOutput)
}

pub type DeleteDeploymentOutput {
  DeleteDeploymentOutput
}

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

pub fn decode_delete_deployment_output_struct() -> decode.Decoder(
  DeleteDeploymentOutput,
) {
  decode.success(DeleteDeploymentOutput)
}

pub fn encode_delete_deployment_input(
  input: DeleteDeploymentRequest,
) -> String {
  json.to_string(encode_delete_deployment_request_struct(input))
}

pub fn decode_delete_deployment_input(
  body: String,
) -> Result(DeleteDeploymentRequest, String) {
  case json.parse(body, decode_delete_deployment_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_delete_deployment_output(
  body: String,
) -> Result(DeleteDeploymentOutput, String) {
  case json.parse(body, decode_delete_deployment_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_delete_deployment_body(
  _input: DeleteDeploymentRequest,
) -> json.Json {
  json.object([])
}

pub fn build_delete_deployment_request(
  input: DeleteDeploymentRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/deployments/{deploymentId}"
  let path = case input.deployment_id {
    option.Some(v) -> rest.substitute_label(path, "deploymentId", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("DELETE", path, headers, body)
}

pub fn parse_delete_deployment_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  _body: BitArray,
) -> Result(DeleteDeploymentOutput, String) {
  Ok(DeleteDeploymentOutput)
}

pub type DeleteDocumentationPartOutput {
  DeleteDocumentationPartOutput
}

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

pub fn decode_delete_documentation_part_output_struct() -> decode.Decoder(
  DeleteDocumentationPartOutput,
) {
  decode.success(DeleteDocumentationPartOutput)
}

pub fn encode_delete_documentation_part_input(
  input: DeleteDocumentationPartRequest,
) -> String {
  json.to_string(encode_delete_documentation_part_request_struct(input))
}

pub fn decode_delete_documentation_part_input(
  body: String,
) -> Result(DeleteDocumentationPartRequest, String) {
  case
    json.parse(body, decode_delete_documentation_part_request_struct_params())
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_delete_documentation_part_output(
  body: String,
) -> Result(DeleteDocumentationPartOutput, String) {
  case json.parse(body, decode_delete_documentation_part_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_delete_documentation_part_body(
  _input: DeleteDocumentationPartRequest,
) -> json.Json {
  json.object([])
}

pub fn build_delete_documentation_part_request(
  input: DeleteDocumentationPartRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/documentation/parts/{documentationPartId}"
  let path = case input.documentation_part_id {
    option.Some(v) ->
      rest.substitute_label(path, "documentationPartId", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("DELETE", path, headers, body)
}

pub fn parse_delete_documentation_part_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  _body: BitArray,
) -> Result(DeleteDocumentationPartOutput, String) {
  Ok(DeleteDocumentationPartOutput)
}

pub type DeleteDocumentationVersionOutput {
  DeleteDocumentationVersionOutput
}

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

pub fn decode_delete_documentation_version_output_struct() -> decode.Decoder(
  DeleteDocumentationVersionOutput,
) {
  decode.success(DeleteDocumentationVersionOutput)
}

pub fn encode_delete_documentation_version_input(
  input: DeleteDocumentationVersionRequest,
) -> String {
  json.to_string(encode_delete_documentation_version_request_struct(input))
}

pub fn decode_delete_documentation_version_input(
  body: String,
) -> Result(DeleteDocumentationVersionRequest, String) {
  case
    json.parse(
      body,
      decode_delete_documentation_version_request_struct_params(),
    )
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_delete_documentation_version_output(
  body: String,
) -> Result(DeleteDocumentationVersionOutput, String) {
  case json.parse(body, decode_delete_documentation_version_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_delete_documentation_version_body(
  _input: DeleteDocumentationVersionRequest,
) -> json.Json {
  json.object([])
}

pub fn build_delete_documentation_version_request(
  input: DeleteDocumentationVersionRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path =
    "/restapis/{restApiId}/documentation/versions/{documentationVersion}"
  let path = case input.documentation_version {
    option.Some(v) ->
      rest.substitute_label(path, "documentationVersion", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("DELETE", path, headers, body)
}

pub fn parse_delete_documentation_version_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  _body: BitArray,
) -> Result(DeleteDocumentationVersionOutput, String) {
  Ok(DeleteDocumentationVersionOutput)
}

pub type DeleteDomainNameOutput {
  DeleteDomainNameOutput
}

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

pub fn decode_delete_domain_name_output_struct() -> decode.Decoder(
  DeleteDomainNameOutput,
) {
  decode.success(DeleteDomainNameOutput)
}

pub fn encode_delete_domain_name_input(
  input: DeleteDomainNameRequest,
) -> String {
  json.to_string(encode_delete_domain_name_request_struct(input))
}

pub fn decode_delete_domain_name_input(
  body: String,
) -> Result(DeleteDomainNameRequest, String) {
  case json.parse(body, decode_delete_domain_name_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_delete_domain_name_output(
  body: String,
) -> Result(DeleteDomainNameOutput, String) {
  case json.parse(body, decode_delete_domain_name_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_delete_domain_name_body(
  _input: DeleteDomainNameRequest,
) -> json.Json {
  json.object([])
}

pub fn build_delete_domain_name_request(
  input: DeleteDomainNameRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/domainnames/{domainName}"
  let path = case input.domain_name {
    option.Some(v) -> rest.substitute_label(path, "domainName", v, False)
    option.None -> path
  }
  let query = ""
  let query = case input.domain_name_id {
    option.Some(v) -> rest.add_query(query, "domainNameId", v)
    option.None -> query
  }
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("DELETE", path, headers, body)
}

pub fn parse_delete_domain_name_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  _body: BitArray,
) -> Result(DeleteDomainNameOutput, String) {
  Ok(DeleteDomainNameOutput)
}

pub type DeleteDomainNameAccessAssociationOutput {
  DeleteDomainNameAccessAssociationOutput
}

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

pub fn decode_delete_domain_name_access_association_output_struct() -> decode.Decoder(
  DeleteDomainNameAccessAssociationOutput,
) {
  decode.success(DeleteDomainNameAccessAssociationOutput)
}

pub fn encode_delete_domain_name_access_association_input(
  input: DeleteDomainNameAccessAssociationRequest,
) -> String {
  json.to_string(encode_delete_domain_name_access_association_request_struct(
    input,
  ))
}

pub fn decode_delete_domain_name_access_association_input(
  body: String,
) -> Result(DeleteDomainNameAccessAssociationRequest, String) {
  case
    json.parse(
      body,
      decode_delete_domain_name_access_association_request_struct_params(),
    )
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_delete_domain_name_access_association_output(
  body: String,
) -> Result(DeleteDomainNameAccessAssociationOutput, String) {
  case
    json.parse(
      body,
      decode_delete_domain_name_access_association_output_struct(),
    )
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_delete_domain_name_access_association_body(
  _input: DeleteDomainNameAccessAssociationRequest,
) -> json.Json {
  json.object([])
}

pub fn build_delete_domain_name_access_association_request(
  input: DeleteDomainNameAccessAssociationRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/domainnameaccessassociations/{domainNameAccessAssociationArn}"
  let path = case input.domain_name_access_association_arn {
    option.Some(v) ->
      rest.substitute_label(path, "domainNameAccessAssociationArn", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("DELETE", path, headers, body)
}

pub fn parse_delete_domain_name_access_association_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  _body: BitArray,
) -> Result(DeleteDomainNameAccessAssociationOutput, String) {
  Ok(DeleteDomainNameAccessAssociationOutput)
}

pub type DeleteGatewayResponseOutput {
  DeleteGatewayResponseOutput
}

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

pub fn decode_delete_gateway_response_output_struct() -> decode.Decoder(
  DeleteGatewayResponseOutput,
) {
  decode.success(DeleteGatewayResponseOutput)
}

pub fn encode_delete_gateway_response_input(
  input: DeleteGatewayResponseRequest,
) -> String {
  json.to_string(encode_delete_gateway_response_request_struct(input))
}

pub fn decode_delete_gateway_response_input(
  body: String,
) -> Result(DeleteGatewayResponseRequest, String) {
  case
    json.parse(body, decode_delete_gateway_response_request_struct_params())
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_delete_gateway_response_output(
  body: String,
) -> Result(DeleteGatewayResponseOutput, String) {
  case json.parse(body, decode_delete_gateway_response_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_delete_gateway_response_body(
  _input: DeleteGatewayResponseRequest,
) -> json.Json {
  json.object([])
}

pub fn build_delete_gateway_response_request(
  input: DeleteGatewayResponseRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/gatewayresponses/{responseType}"
  let path = case input.response_type {
    option.Some(v) ->
      rest.substitute_label(
        path,
        "responseType",
        rest.enum_wire_value(encode_gateway_response_type_enum(v)),
        False,
      )
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("DELETE", path, headers, body)
}

pub fn parse_delete_gateway_response_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  _body: BitArray,
) -> Result(DeleteGatewayResponseOutput, String) {
  Ok(DeleteGatewayResponseOutput)
}

pub type DeleteIntegrationOutput {
  DeleteIntegrationOutput
}

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

pub fn decode_delete_integration_output_struct() -> decode.Decoder(
  DeleteIntegrationOutput,
) {
  decode.success(DeleteIntegrationOutput)
}

pub fn encode_delete_integration_input(
  input: DeleteIntegrationRequest,
) -> String {
  json.to_string(encode_delete_integration_request_struct(input))
}

pub fn decode_delete_integration_input(
  body: String,
) -> Result(DeleteIntegrationRequest, String) {
  case json.parse(body, decode_delete_integration_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_delete_integration_output(
  body: String,
) -> Result(DeleteIntegrationOutput, String) {
  case json.parse(body, decode_delete_integration_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_delete_integration_body(
  _input: DeleteIntegrationRequest,
) -> json.Json {
  json.object([])
}

pub fn build_delete_integration_request(
  input: DeleteIntegrationRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path =
    "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration"
  let path = case input.http_method {
    option.Some(v) -> rest.substitute_label(path, "httpMethod", v, False)
    option.None -> path
  }
  let path = case input.resource_id {
    option.Some(v) -> rest.substitute_label(path, "resourceId", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("DELETE", path, headers, body)
}

pub fn parse_delete_integration_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  _body: BitArray,
) -> Result(DeleteIntegrationOutput, String) {
  Ok(DeleteIntegrationOutput)
}

pub type DeleteIntegrationResponseOutput {
  DeleteIntegrationResponseOutput
}

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

pub fn decode_delete_integration_response_output_struct() -> decode.Decoder(
  DeleteIntegrationResponseOutput,
) {
  decode.success(DeleteIntegrationResponseOutput)
}

pub fn encode_delete_integration_response_input(
  input: DeleteIntegrationResponseRequest,
) -> String {
  json.to_string(encode_delete_integration_response_request_struct(input))
}

pub fn decode_delete_integration_response_input(
  body: String,
) -> Result(DeleteIntegrationResponseRequest, String) {
  case
    json.parse(body, decode_delete_integration_response_request_struct_params())
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_delete_integration_response_output(
  body: String,
) -> Result(DeleteIntegrationResponseOutput, String) {
  case json.parse(body, decode_delete_integration_response_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_delete_integration_response_body(
  _input: DeleteIntegrationResponseRequest,
) -> json.Json {
  json.object([])
}

pub fn build_delete_integration_response_request(
  input: DeleteIntegrationResponseRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path =
    "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration/responses/{statusCode}"
  let path = case input.http_method {
    option.Some(v) -> rest.substitute_label(path, "httpMethod", v, False)
    option.None -> path
  }
  let path = case input.resource_id {
    option.Some(v) -> rest.substitute_label(path, "resourceId", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let path = case input.status_code {
    option.Some(v) -> rest.substitute_label(path, "statusCode", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("DELETE", path, headers, body)
}

pub fn parse_delete_integration_response_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  _body: BitArray,
) -> Result(DeleteIntegrationResponseOutput, String) {
  Ok(DeleteIntegrationResponseOutput)
}

pub type DeleteMethodOutput {
  DeleteMethodOutput
}

pub fn encode_delete_method_output_struct(_v: DeleteMethodOutput) -> json.Json {
  json.object([])
}

pub fn decode_delete_method_output_struct() -> decode.Decoder(
  DeleteMethodOutput,
) {
  decode.success(DeleteMethodOutput)
}

pub fn encode_delete_method_input(input: DeleteMethodRequest) -> String {
  json.to_string(encode_delete_method_request_struct(input))
}

pub fn decode_delete_method_input(
  body: String,
) -> Result(DeleteMethodRequest, String) {
  case json.parse(body, decode_delete_method_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_delete_method_output(
  body: String,
) -> Result(DeleteMethodOutput, String) {
  case json.parse(body, decode_delete_method_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_delete_method_body(_input: DeleteMethodRequest) -> json.Json {
  json.object([])
}

pub fn build_delete_method_request(
  input: DeleteMethodRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}"
  let path = case input.http_method {
    option.Some(v) -> rest.substitute_label(path, "httpMethod", v, False)
    option.None -> path
  }
  let path = case input.resource_id {
    option.Some(v) -> rest.substitute_label(path, "resourceId", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("DELETE", path, headers, body)
}

pub fn parse_delete_method_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  _body: BitArray,
) -> Result(DeleteMethodOutput, String) {
  Ok(DeleteMethodOutput)
}

pub type DeleteMethodResponseOutput {
  DeleteMethodResponseOutput
}

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

pub fn decode_delete_method_response_output_struct() -> decode.Decoder(
  DeleteMethodResponseOutput,
) {
  decode.success(DeleteMethodResponseOutput)
}

pub fn encode_delete_method_response_input(
  input: DeleteMethodResponseRequest,
) -> String {
  json.to_string(encode_delete_method_response_request_struct(input))
}

pub fn decode_delete_method_response_input(
  body: String,
) -> Result(DeleteMethodResponseRequest, String) {
  case json.parse(body, decode_delete_method_response_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_delete_method_response_output(
  body: String,
) -> Result(DeleteMethodResponseOutput, String) {
  case json.parse(body, decode_delete_method_response_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_delete_method_response_body(
  _input: DeleteMethodResponseRequest,
) -> json.Json {
  json.object([])
}

pub fn build_delete_method_response_request(
  input: DeleteMethodResponseRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path =
    "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/responses/{statusCode}"
  let path = case input.http_method {
    option.Some(v) -> rest.substitute_label(path, "httpMethod", v, False)
    option.None -> path
  }
  let path = case input.resource_id {
    option.Some(v) -> rest.substitute_label(path, "resourceId", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let path = case input.status_code {
    option.Some(v) -> rest.substitute_label(path, "statusCode", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("DELETE", path, headers, body)
}

pub fn parse_delete_method_response_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  _body: BitArray,
) -> Result(DeleteMethodResponseOutput, String) {
  Ok(DeleteMethodResponseOutput)
}

pub type DeleteModelOutput {
  DeleteModelOutput
}

pub fn encode_delete_model_output_struct(_v: DeleteModelOutput) -> json.Json {
  json.object([])
}

pub fn decode_delete_model_output_struct() -> decode.Decoder(DeleteModelOutput) {
  decode.success(DeleteModelOutput)
}

pub fn encode_delete_model_input(input: DeleteModelRequest) -> String {
  json.to_string(encode_delete_model_request_struct(input))
}

pub fn decode_delete_model_input(
  body: String,
) -> Result(DeleteModelRequest, String) {
  case json.parse(body, decode_delete_model_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_delete_model_output(
  body: String,
) -> Result(DeleteModelOutput, String) {
  case json.parse(body, decode_delete_model_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_delete_model_body(_input: DeleteModelRequest) -> json.Json {
  json.object([])
}

pub fn build_delete_model_request(
  input: DeleteModelRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/models/{modelName}"
  let path = case input.model_name {
    option.Some(v) -> rest.substitute_label(path, "modelName", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("DELETE", path, headers, body)
}

pub fn parse_delete_model_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  _body: BitArray,
) -> Result(DeleteModelOutput, String) {
  Ok(DeleteModelOutput)
}

pub type DeleteRequestValidatorOutput {
  DeleteRequestValidatorOutput
}

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

pub fn decode_delete_request_validator_output_struct() -> decode.Decoder(
  DeleteRequestValidatorOutput,
) {
  decode.success(DeleteRequestValidatorOutput)
}

pub fn encode_delete_request_validator_input(
  input: DeleteRequestValidatorRequest,
) -> String {
  json.to_string(encode_delete_request_validator_request_struct(input))
}

pub fn decode_delete_request_validator_input(
  body: String,
) -> Result(DeleteRequestValidatorRequest, String) {
  case
    json.parse(body, decode_delete_request_validator_request_struct_params())
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_delete_request_validator_output(
  body: String,
) -> Result(DeleteRequestValidatorOutput, String) {
  case json.parse(body, decode_delete_request_validator_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_delete_request_validator_body(
  _input: DeleteRequestValidatorRequest,
) -> json.Json {
  json.object([])
}

pub fn build_delete_request_validator_request(
  input: DeleteRequestValidatorRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/requestvalidators/{requestValidatorId}"
  let path = case input.request_validator_id {
    option.Some(v) ->
      rest.substitute_label(path, "requestValidatorId", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("DELETE", path, headers, body)
}

pub fn parse_delete_request_validator_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  _body: BitArray,
) -> Result(DeleteRequestValidatorOutput, String) {
  Ok(DeleteRequestValidatorOutput)
}

pub type DeleteResourceOutput {
  DeleteResourceOutput
}

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

pub fn decode_delete_resource_output_struct() -> decode.Decoder(
  DeleteResourceOutput,
) {
  decode.success(DeleteResourceOutput)
}

pub fn encode_delete_resource_input(input: DeleteResourceRequest) -> String {
  json.to_string(encode_delete_resource_request_struct(input))
}

pub fn decode_delete_resource_input(
  body: String,
) -> Result(DeleteResourceRequest, String) {
  case json.parse(body, decode_delete_resource_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_delete_resource_output(
  body: String,
) -> Result(DeleteResourceOutput, String) {
  case json.parse(body, decode_delete_resource_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_delete_resource_body(_input: DeleteResourceRequest) -> json.Json {
  json.object([])
}

pub fn build_delete_resource_request(
  input: DeleteResourceRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/resources/{resourceId}"
  let path = case input.resource_id {
    option.Some(v) -> rest.substitute_label(path, "resourceId", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("DELETE", path, headers, body)
}

pub fn parse_delete_resource_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  _body: BitArray,
) -> Result(DeleteResourceOutput, String) {
  Ok(DeleteResourceOutput)
}

pub type DeleteRestApiOutput {
  DeleteRestApiOutput
}

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

pub fn decode_delete_rest_api_output_struct() -> decode.Decoder(
  DeleteRestApiOutput,
) {
  decode.success(DeleteRestApiOutput)
}

pub fn encode_delete_rest_api_input(input: DeleteRestApiRequest) -> String {
  json.to_string(encode_delete_rest_api_request_struct(input))
}

pub fn decode_delete_rest_api_input(
  body: String,
) -> Result(DeleteRestApiRequest, String) {
  case json.parse(body, decode_delete_rest_api_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_delete_rest_api_output(
  body: String,
) -> Result(DeleteRestApiOutput, String) {
  case json.parse(body, decode_delete_rest_api_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_delete_rest_api_body(_input: DeleteRestApiRequest) -> json.Json {
  json.object([])
}

pub fn build_delete_rest_api_request(
  input: DeleteRestApiRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}"
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("DELETE", path, headers, body)
}

pub fn parse_delete_rest_api_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  _body: BitArray,
) -> Result(DeleteRestApiOutput, String) {
  Ok(DeleteRestApiOutput)
}

pub type DeleteStageOutput {
  DeleteStageOutput
}

pub fn encode_delete_stage_output_struct(_v: DeleteStageOutput) -> json.Json {
  json.object([])
}

pub fn decode_delete_stage_output_struct() -> decode.Decoder(DeleteStageOutput) {
  decode.success(DeleteStageOutput)
}

pub fn encode_delete_stage_input(input: DeleteStageRequest) -> String {
  json.to_string(encode_delete_stage_request_struct(input))
}

pub fn decode_delete_stage_input(
  body: String,
) -> Result(DeleteStageRequest, String) {
  case json.parse(body, decode_delete_stage_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_delete_stage_output(
  body: String,
) -> Result(DeleteStageOutput, String) {
  case json.parse(body, decode_delete_stage_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_delete_stage_body(_input: DeleteStageRequest) -> json.Json {
  json.object([])
}

pub fn build_delete_stage_request(
  input: DeleteStageRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/stages/{stageName}"
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let path = case input.stage_name {
    option.Some(v) -> rest.substitute_label(path, "stageName", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("DELETE", path, headers, body)
}

pub fn parse_delete_stage_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  _body: BitArray,
) -> Result(DeleteStageOutput, String) {
  Ok(DeleteStageOutput)
}

pub type DeleteUsagePlanOutput {
  DeleteUsagePlanOutput
}

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

pub fn decode_delete_usage_plan_output_struct() -> decode.Decoder(
  DeleteUsagePlanOutput,
) {
  decode.success(DeleteUsagePlanOutput)
}

pub fn encode_delete_usage_plan_input(input: DeleteUsagePlanRequest) -> String {
  json.to_string(encode_delete_usage_plan_request_struct(input))
}

pub fn decode_delete_usage_plan_input(
  body: String,
) -> Result(DeleteUsagePlanRequest, String) {
  case json.parse(body, decode_delete_usage_plan_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_delete_usage_plan_output(
  body: String,
) -> Result(DeleteUsagePlanOutput, String) {
  case json.parse(body, decode_delete_usage_plan_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_delete_usage_plan_body(
  _input: DeleteUsagePlanRequest,
) -> json.Json {
  json.object([])
}

pub fn build_delete_usage_plan_request(
  input: DeleteUsagePlanRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/usageplans/{usagePlanId}"
  let path = case input.usage_plan_id {
    option.Some(v) -> rest.substitute_label(path, "usagePlanId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("DELETE", path, headers, body)
}

pub fn parse_delete_usage_plan_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  _body: BitArray,
) -> Result(DeleteUsagePlanOutput, String) {
  Ok(DeleteUsagePlanOutput)
}

pub type DeleteUsagePlanKeyOutput {
  DeleteUsagePlanKeyOutput
}

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

pub fn decode_delete_usage_plan_key_output_struct() -> decode.Decoder(
  DeleteUsagePlanKeyOutput,
) {
  decode.success(DeleteUsagePlanKeyOutput)
}

pub fn encode_delete_usage_plan_key_input(
  input: DeleteUsagePlanKeyRequest,
) -> String {
  json.to_string(encode_delete_usage_plan_key_request_struct(input))
}

pub fn decode_delete_usage_plan_key_input(
  body: String,
) -> Result(DeleteUsagePlanKeyRequest, String) {
  case json.parse(body, decode_delete_usage_plan_key_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_delete_usage_plan_key_output(
  body: String,
) -> Result(DeleteUsagePlanKeyOutput, String) {
  case json.parse(body, decode_delete_usage_plan_key_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_delete_usage_plan_key_body(
  _input: DeleteUsagePlanKeyRequest,
) -> json.Json {
  json.object([])
}

pub fn build_delete_usage_plan_key_request(
  input: DeleteUsagePlanKeyRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/usageplans/{usagePlanId}/keys/{keyId}"
  let path = case input.key_id {
    option.Some(v) -> rest.substitute_label(path, "keyId", v, False)
    option.None -> path
  }
  let path = case input.usage_plan_id {
    option.Some(v) -> rest.substitute_label(path, "usagePlanId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("DELETE", path, headers, body)
}

pub fn parse_delete_usage_plan_key_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  _body: BitArray,
) -> Result(DeleteUsagePlanKeyOutput, String) {
  Ok(DeleteUsagePlanKeyOutput)
}

pub type DeleteVpcLinkOutput {
  DeleteVpcLinkOutput
}

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

pub fn decode_delete_vpc_link_output_struct() -> decode.Decoder(
  DeleteVpcLinkOutput,
) {
  decode.success(DeleteVpcLinkOutput)
}

pub fn encode_delete_vpc_link_input(input: DeleteVpcLinkRequest) -> String {
  json.to_string(encode_delete_vpc_link_request_struct(input))
}

pub fn decode_delete_vpc_link_input(
  body: String,
) -> Result(DeleteVpcLinkRequest, String) {
  case json.parse(body, decode_delete_vpc_link_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_delete_vpc_link_output(
  body: String,
) -> Result(DeleteVpcLinkOutput, String) {
  case json.parse(body, decode_delete_vpc_link_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_delete_vpc_link_body(_input: DeleteVpcLinkRequest) -> json.Json {
  json.object([])
}

pub fn build_delete_vpc_link_request(
  input: DeleteVpcLinkRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/vpclinks/{vpcLinkId}"
  let path = case input.vpc_link_id {
    option.Some(v) -> rest.substitute_label(path, "vpcLinkId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("DELETE", path, headers, body)
}

pub fn parse_delete_vpc_link_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  _body: BitArray,
) -> Result(DeleteVpcLinkOutput, String) {
  Ok(DeleteVpcLinkOutput)
}

pub type FlushStageAuthorizersCacheOutput {
  FlushStageAuthorizersCacheOutput
}

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

pub fn decode_flush_stage_authorizers_cache_output_struct() -> decode.Decoder(
  FlushStageAuthorizersCacheOutput,
) {
  decode.success(FlushStageAuthorizersCacheOutput)
}

pub fn encode_flush_stage_authorizers_cache_input(
  input: FlushStageAuthorizersCacheRequest,
) -> String {
  json.to_string(encode_flush_stage_authorizers_cache_request_struct(input))
}

pub fn decode_flush_stage_authorizers_cache_input(
  body: String,
) -> Result(FlushStageAuthorizersCacheRequest, String) {
  case
    json.parse(
      body,
      decode_flush_stage_authorizers_cache_request_struct_params(),
    )
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_flush_stage_authorizers_cache_output(
  body: String,
) -> Result(FlushStageAuthorizersCacheOutput, String) {
  case json.parse(body, decode_flush_stage_authorizers_cache_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_flush_stage_authorizers_cache_body(
  _input: FlushStageAuthorizersCacheRequest,
) -> json.Json {
  json.object([])
}

pub fn build_flush_stage_authorizers_cache_request(
  input: FlushStageAuthorizersCacheRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/stages/{stageName}/cache/authorizers"
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let path = case input.stage_name {
    option.Some(v) -> rest.substitute_label(path, "stageName", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("DELETE", path, headers, body)
}

pub fn parse_flush_stage_authorizers_cache_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  _body: BitArray,
) -> Result(FlushStageAuthorizersCacheOutput, String) {
  Ok(FlushStageAuthorizersCacheOutput)
}

pub type FlushStageCacheOutput {
  FlushStageCacheOutput
}

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

pub fn decode_flush_stage_cache_output_struct() -> decode.Decoder(
  FlushStageCacheOutput,
) {
  decode.success(FlushStageCacheOutput)
}

pub fn encode_flush_stage_cache_input(input: FlushStageCacheRequest) -> String {
  json.to_string(encode_flush_stage_cache_request_struct(input))
}

pub fn decode_flush_stage_cache_input(
  body: String,
) -> Result(FlushStageCacheRequest, String) {
  case json.parse(body, decode_flush_stage_cache_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_flush_stage_cache_output(
  body: String,
) -> Result(FlushStageCacheOutput, String) {
  case json.parse(body, decode_flush_stage_cache_output_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_flush_stage_cache_body(
  _input: FlushStageCacheRequest,
) -> json.Json {
  json.object([])
}

pub fn build_flush_stage_cache_request(
  input: FlushStageCacheRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/stages/{stageName}/cache/data"
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let path = case input.stage_name {
    option.Some(v) -> rest.substitute_label(path, "stageName", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("DELETE", path, headers, body)
}

pub fn parse_flush_stage_cache_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  _body: BitArray,
) -> Result(FlushStageCacheOutput, String) {
  Ok(FlushStageCacheOutput)
}

pub fn encode_generate_client_certificate_input(
  input: GenerateClientCertificateRequest,
) -> String {
  json.to_string(encode_generate_client_certificate_request_struct(input))
}

pub fn decode_generate_client_certificate_input(
  body: String,
) -> Result(GenerateClientCertificateRequest, String) {
  case
    json.parse(body, decode_generate_client_certificate_request_struct_params())
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_generate_client_certificate_output(
  body: String,
) -> Result(ClientCertificate, String) {
  case json.parse(body, decode_client_certificate_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_generate_client_certificate_body(
  input: GenerateClientCertificateRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.description {
    option.Some(v) -> [#("description", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.tags {
    option.Some(v) -> [
      #(
        "tags",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_generate_client_certificate_request(
  input: GenerateClientCertificateRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/clientcertificates"
  let query = ""
  let headers = dict.new()
  let body_json = encode_generate_client_certificate_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("POST", path, headers, body)
}

pub fn parse_generate_client_certificate_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(ClientCertificate, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_generate_client_certificate_output("{}")
        _ -> decode_generate_client_certificate_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_account_input(input: GetAccountRequest) -> String {
  json.to_string(encode_get_account_request_struct(input))
}

pub fn decode_get_account_input(
  body: String,
) -> Result(GetAccountRequest, String) {
  case json.parse(body, decode_get_account_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_account_output(body: String) -> Result(Account, String) {
  case json.parse(body, decode_account_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_account_body(_input: GetAccountRequest) -> json.Json {
  json.object([])
}

pub fn build_get_account_request(
  _input: GetAccountRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/account"
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_account_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Account, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_account_output("{}")
        _ -> decode_get_account_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_api_key_input(input: GetApiKeyRequest) -> String {
  json.to_string(encode_get_api_key_request_struct(input))
}

pub fn decode_get_api_key_input(
  body: String,
) -> Result(GetApiKeyRequest, String) {
  case json.parse(body, decode_get_api_key_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_api_key_output(body: String) -> Result(ApiKey, String) {
  case json.parse(body, decode_api_key_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_api_key_body(_input: GetApiKeyRequest) -> json.Json {
  json.object([])
}

pub fn build_get_api_key_request(
  input: GetApiKeyRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/apikeys/{apiKey}"
  let path = case input.api_key {
    option.Some(v) -> rest.substitute_label(path, "apiKey", v, False)
    option.None -> path
  }
  let query = ""
  let query = case input.include_value {
    option.Some(v) ->
      rest.add_query(query, "includeValue", rest.bool_to_query(v))
    option.None -> query
  }
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_api_key_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(ApiKey, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_api_key_output("{}")
        _ -> decode_get_api_key_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_api_keys_input(input: GetApiKeysRequest) -> String {
  json.to_string(encode_get_api_keys_request_struct(input))
}

pub fn decode_get_api_keys_input(
  body: String,
) -> Result(GetApiKeysRequest, String) {
  case json.parse(body, decode_get_api_keys_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_api_keys_output(body: String) -> Result(ApiKeys, String) {
  case json.parse(body, decode_api_keys_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_api_keys_body(_input: GetApiKeysRequest) -> json.Json {
  json.object([])
}

pub fn build_get_api_keys_request(
  input: GetApiKeysRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/apikeys"
  let query = ""
  let query = case input.customer_id {
    option.Some(v) -> rest.add_query(query, "customerId", v)
    option.None -> query
  }
  let query = case input.include_values {
    option.Some(v) ->
      rest.add_query(query, "includeValues", rest.bool_to_query(v))
    option.None -> query
  }
  let query = case input.limit {
    option.Some(v) -> rest.add_query(query, "limit", rest.int_to_query(v))
    option.None -> query
  }
  let query = case input.name_query {
    option.Some(v) -> rest.add_query(query, "name", v)
    option.None -> query
  }
  let query = case input.position {
    option.Some(v) -> rest.add_query(query, "position", v)
    option.None -> query
  }
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_api_keys_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(ApiKeys, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_api_keys_output("{}")
        _ -> decode_get_api_keys_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_authorizer_input(input: GetAuthorizerRequest) -> String {
  json.to_string(encode_get_authorizer_request_struct(input))
}

pub fn decode_get_authorizer_input(
  body: String,
) -> Result(GetAuthorizerRequest, String) {
  case json.parse(body, decode_get_authorizer_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_authorizer_output(
  body: String,
) -> Result(Authorizer, String) {
  case json.parse(body, decode_authorizer_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_authorizer_body(_input: GetAuthorizerRequest) -> json.Json {
  json.object([])
}

pub fn build_get_authorizer_request(
  input: GetAuthorizerRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/authorizers/{authorizerId}"
  let path = case input.authorizer_id {
    option.Some(v) -> rest.substitute_label(path, "authorizerId", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_authorizer_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Authorizer, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_authorizer_output("{}")
        _ -> decode_get_authorizer_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_authorizers_input(input: GetAuthorizersRequest) -> String {
  json.to_string(encode_get_authorizers_request_struct(input))
}

pub fn decode_get_authorizers_input(
  body: String,
) -> Result(GetAuthorizersRequest, String) {
  case json.parse(body, decode_get_authorizers_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_authorizers_output(
  body: String,
) -> Result(Authorizers, String) {
  case json.parse(body, decode_authorizers_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_authorizers_body(_input: GetAuthorizersRequest) -> json.Json {
  json.object([])
}

pub fn build_get_authorizers_request(
  input: GetAuthorizersRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/authorizers"
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let query = case input.limit {
    option.Some(v) -> rest.add_query(query, "limit", rest.int_to_query(v))
    option.None -> query
  }
  let query = case input.position {
    option.Some(v) -> rest.add_query(query, "position", v)
    option.None -> query
  }
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_authorizers_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Authorizers, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_authorizers_output("{}")
        _ -> decode_get_authorizers_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_base_path_mapping_input(
  input: GetBasePathMappingRequest,
) -> String {
  json.to_string(encode_get_base_path_mapping_request_struct(input))
}

pub fn decode_get_base_path_mapping_input(
  body: String,
) -> Result(GetBasePathMappingRequest, String) {
  case json.parse(body, decode_get_base_path_mapping_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_base_path_mapping_output(
  body: String,
) -> Result(BasePathMapping, String) {
  case json.parse(body, decode_base_path_mapping_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_base_path_mapping_body(
  _input: GetBasePathMappingRequest,
) -> json.Json {
  json.object([])
}

pub fn build_get_base_path_mapping_request(
  input: GetBasePathMappingRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/domainnames/{domainName}/basepathmappings/{basePath}"
  let path = case input.base_path {
    option.Some(v) -> rest.substitute_label(path, "basePath", v, False)
    option.None -> path
  }
  let path = case input.domain_name {
    option.Some(v) -> rest.substitute_label(path, "domainName", v, False)
    option.None -> path
  }
  let query = ""
  let query = case input.domain_name_id {
    option.Some(v) -> rest.add_query(query, "domainNameId", v)
    option.None -> query
  }
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_base_path_mapping_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(BasePathMapping, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_base_path_mapping_output("{}")
        _ -> decode_get_base_path_mapping_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_base_path_mappings_input(
  input: GetBasePathMappingsRequest,
) -> String {
  json.to_string(encode_get_base_path_mappings_request_struct(input))
}

pub fn decode_get_base_path_mappings_input(
  body: String,
) -> Result(GetBasePathMappingsRequest, String) {
  case json.parse(body, decode_get_base_path_mappings_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_base_path_mappings_output(
  body: String,
) -> Result(BasePathMappings, String) {
  case json.parse(body, decode_base_path_mappings_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_base_path_mappings_body(
  _input: GetBasePathMappingsRequest,
) -> json.Json {
  json.object([])
}

pub fn build_get_base_path_mappings_request(
  input: GetBasePathMappingsRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/domainnames/{domainName}/basepathmappings"
  let path = case input.domain_name {
    option.Some(v) -> rest.substitute_label(path, "domainName", v, False)
    option.None -> path
  }
  let query = ""
  let query = case input.domain_name_id {
    option.Some(v) -> rest.add_query(query, "domainNameId", v)
    option.None -> query
  }
  let query = case input.limit {
    option.Some(v) -> rest.add_query(query, "limit", rest.int_to_query(v))
    option.None -> query
  }
  let query = case input.position {
    option.Some(v) -> rest.add_query(query, "position", v)
    option.None -> query
  }
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_base_path_mappings_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(BasePathMappings, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_base_path_mappings_output("{}")
        _ -> decode_get_base_path_mappings_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_client_certificate_input(
  input: GetClientCertificateRequest,
) -> String {
  json.to_string(encode_get_client_certificate_request_struct(input))
}

pub fn decode_get_client_certificate_input(
  body: String,
) -> Result(GetClientCertificateRequest, String) {
  case json.parse(body, decode_get_client_certificate_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_client_certificate_output(
  body: String,
) -> Result(ClientCertificate, String) {
  case json.parse(body, decode_client_certificate_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_client_certificate_body(
  _input: GetClientCertificateRequest,
) -> json.Json {
  json.object([])
}

pub fn build_get_client_certificate_request(
  input: GetClientCertificateRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/clientcertificates/{clientCertificateId}"
  let path = case input.client_certificate_id {
    option.Some(v) ->
      rest.substitute_label(path, "clientCertificateId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_client_certificate_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(ClientCertificate, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_client_certificate_output("{}")
        _ -> decode_get_client_certificate_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_client_certificates_input(
  input: GetClientCertificatesRequest,
) -> String {
  json.to_string(encode_get_client_certificates_request_struct(input))
}

pub fn decode_get_client_certificates_input(
  body: String,
) -> Result(GetClientCertificatesRequest, String) {
  case
    json.parse(body, decode_get_client_certificates_request_struct_params())
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_client_certificates_output(
  body: String,
) -> Result(ClientCertificates, String) {
  case json.parse(body, decode_client_certificates_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_client_certificates_body(
  _input: GetClientCertificatesRequest,
) -> json.Json {
  json.object([])
}

pub fn build_get_client_certificates_request(
  input: GetClientCertificatesRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/clientcertificates"
  let query = ""
  let query = case input.limit {
    option.Some(v) -> rest.add_query(query, "limit", rest.int_to_query(v))
    option.None -> query
  }
  let query = case input.position {
    option.Some(v) -> rest.add_query(query, "position", v)
    option.None -> query
  }
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_client_certificates_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(ClientCertificates, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_client_certificates_output("{}")
        _ -> decode_get_client_certificates_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_deployment_input(input: GetDeploymentRequest) -> String {
  json.to_string(encode_get_deployment_request_struct(input))
}

pub fn decode_get_deployment_input(
  body: String,
) -> Result(GetDeploymentRequest, String) {
  case json.parse(body, decode_get_deployment_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_deployment_output(
  body: String,
) -> Result(Deployment, String) {
  case json.parse(body, decode_deployment_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_deployment_body(_input: GetDeploymentRequest) -> json.Json {
  json.object([])
}

pub fn build_get_deployment_request(
  input: GetDeploymentRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/deployments/{deploymentId}"
  let path = case input.deployment_id {
    option.Some(v) -> rest.substitute_label(path, "deploymentId", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let query = case input.embed {
    option.Some(xs) ->
      list.fold(xs, query, fn(q, item) {
        {
          let v = item
          rest.add_query(q, "embed", v)
        }
      })
    option.None -> query
  }
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_deployment_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Deployment, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_deployment_output("{}")
        _ -> decode_get_deployment_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_deployments_input(input: GetDeploymentsRequest) -> String {
  json.to_string(encode_get_deployments_request_struct(input))
}

pub fn decode_get_deployments_input(
  body: String,
) -> Result(GetDeploymentsRequest, String) {
  case json.parse(body, decode_get_deployments_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_deployments_output(
  body: String,
) -> Result(Deployments, String) {
  case json.parse(body, decode_deployments_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_deployments_body(_input: GetDeploymentsRequest) -> json.Json {
  json.object([])
}

pub fn build_get_deployments_request(
  input: GetDeploymentsRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/deployments"
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let query = case input.limit {
    option.Some(v) -> rest.add_query(query, "limit", rest.int_to_query(v))
    option.None -> query
  }
  let query = case input.position {
    option.Some(v) -> rest.add_query(query, "position", v)
    option.None -> query
  }
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_deployments_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Deployments, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_deployments_output("{}")
        _ -> decode_get_deployments_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_documentation_part_input(
  input: GetDocumentationPartRequest,
) -> String {
  json.to_string(encode_get_documentation_part_request_struct(input))
}

pub fn decode_get_documentation_part_input(
  body: String,
) -> Result(GetDocumentationPartRequest, String) {
  case json.parse(body, decode_get_documentation_part_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_documentation_part_output(
  body: String,
) -> Result(DocumentationPart, String) {
  case json.parse(body, decode_documentation_part_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_documentation_part_body(
  _input: GetDocumentationPartRequest,
) -> json.Json {
  json.object([])
}

pub fn build_get_documentation_part_request(
  input: GetDocumentationPartRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/documentation/parts/{documentationPartId}"
  let path = case input.documentation_part_id {
    option.Some(v) ->
      rest.substitute_label(path, "documentationPartId", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_documentation_part_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(DocumentationPart, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_documentation_part_output("{}")
        _ -> decode_get_documentation_part_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_documentation_parts_input(
  input: GetDocumentationPartsRequest,
) -> String {
  json.to_string(encode_get_documentation_parts_request_struct(input))
}

pub fn decode_get_documentation_parts_input(
  body: String,
) -> Result(GetDocumentationPartsRequest, String) {
  case
    json.parse(body, decode_get_documentation_parts_request_struct_params())
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_documentation_parts_output(
  body: String,
) -> Result(DocumentationParts, String) {
  case json.parse(body, decode_documentation_parts_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_documentation_parts_body(
  _input: GetDocumentationPartsRequest,
) -> json.Json {
  json.object([])
}

pub fn build_get_documentation_parts_request(
  input: GetDocumentationPartsRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/documentation/parts"
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let query = case input.limit {
    option.Some(v) -> rest.add_query(query, "limit", rest.int_to_query(v))
    option.None -> query
  }
  let query = case input.location_status {
    option.Some(v) ->
      rest.add_query(
        query,
        "locationStatus",
        rest.enum_wire_value(encode_location_status_type_enum(v)),
      )
    option.None -> query
  }
  let query = case input.name_query {
    option.Some(v) -> rest.add_query(query, "name", v)
    option.None -> query
  }
  let query = case input.path {
    option.Some(v) -> rest.add_query(query, "path", v)
    option.None -> query
  }
  let query = case input.position {
    option.Some(v) -> rest.add_query(query, "position", v)
    option.None -> query
  }
  let query = case input.type_ {
    option.Some(v) ->
      rest.add_query(
        query,
        "type",
        rest.enum_wire_value(encode_documentation_part_type_enum(v)),
      )
    option.None -> query
  }
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_documentation_parts_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(DocumentationParts, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_documentation_parts_output("{}")
        _ -> decode_get_documentation_parts_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_documentation_version_input(
  input: GetDocumentationVersionRequest,
) -> String {
  json.to_string(encode_get_documentation_version_request_struct(input))
}

pub fn decode_get_documentation_version_input(
  body: String,
) -> Result(GetDocumentationVersionRequest, String) {
  case
    json.parse(body, decode_get_documentation_version_request_struct_params())
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_documentation_version_output(
  body: String,
) -> Result(DocumentationVersion, String) {
  case json.parse(body, decode_documentation_version_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_documentation_version_body(
  _input: GetDocumentationVersionRequest,
) -> json.Json {
  json.object([])
}

pub fn build_get_documentation_version_request(
  input: GetDocumentationVersionRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path =
    "/restapis/{restApiId}/documentation/versions/{documentationVersion}"
  let path = case input.documentation_version {
    option.Some(v) ->
      rest.substitute_label(path, "documentationVersion", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_documentation_version_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(DocumentationVersion, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_documentation_version_output("{}")
        _ -> decode_get_documentation_version_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_documentation_versions_input(
  input: GetDocumentationVersionsRequest,
) -> String {
  json.to_string(encode_get_documentation_versions_request_struct(input))
}

pub fn decode_get_documentation_versions_input(
  body: String,
) -> Result(GetDocumentationVersionsRequest, String) {
  case
    json.parse(body, decode_get_documentation_versions_request_struct_params())
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_documentation_versions_output(
  body: String,
) -> Result(DocumentationVersions, String) {
  case json.parse(body, decode_documentation_versions_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_documentation_versions_body(
  _input: GetDocumentationVersionsRequest,
) -> json.Json {
  json.object([])
}

pub fn build_get_documentation_versions_request(
  input: GetDocumentationVersionsRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/documentation/versions"
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let query = case input.limit {
    option.Some(v) -> rest.add_query(query, "limit", rest.int_to_query(v))
    option.None -> query
  }
  let query = case input.position {
    option.Some(v) -> rest.add_query(query, "position", v)
    option.None -> query
  }
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_documentation_versions_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(DocumentationVersions, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_documentation_versions_output("{}")
        _ -> decode_get_documentation_versions_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_domain_name_input(input: GetDomainNameRequest) -> String {
  json.to_string(encode_get_domain_name_request_struct(input))
}

pub fn decode_get_domain_name_input(
  body: String,
) -> Result(GetDomainNameRequest, String) {
  case json.parse(body, decode_get_domain_name_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_domain_name_output(
  body: String,
) -> Result(DomainName, String) {
  case json.parse(body, decode_domain_name_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_domain_name_body(_input: GetDomainNameRequest) -> json.Json {
  json.object([])
}

pub fn build_get_domain_name_request(
  input: GetDomainNameRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/domainnames/{domainName}"
  let path = case input.domain_name {
    option.Some(v) -> rest.substitute_label(path, "domainName", v, False)
    option.None -> path
  }
  let query = ""
  let query = case input.domain_name_id {
    option.Some(v) -> rest.add_query(query, "domainNameId", v)
    option.None -> query
  }
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_domain_name_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(DomainName, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_domain_name_output("{}")
        _ -> decode_get_domain_name_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_domain_name_access_associations_input(
  input: GetDomainNameAccessAssociationsRequest,
) -> String {
  json.to_string(encode_get_domain_name_access_associations_request_struct(
    input,
  ))
}

pub fn decode_get_domain_name_access_associations_input(
  body: String,
) -> Result(GetDomainNameAccessAssociationsRequest, String) {
  case
    json.parse(
      body,
      decode_get_domain_name_access_associations_request_struct_params(),
    )
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_domain_name_access_associations_output(
  body: String,
) -> Result(DomainNameAccessAssociations, String) {
  case json.parse(body, decode_domain_name_access_associations_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_domain_name_access_associations_body(
  _input: GetDomainNameAccessAssociationsRequest,
) -> json.Json {
  json.object([])
}

pub fn build_get_domain_name_access_associations_request(
  input: GetDomainNameAccessAssociationsRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/domainnameaccessassociations"
  let query = ""
  let query = case input.limit {
    option.Some(v) -> rest.add_query(query, "limit", rest.int_to_query(v))
    option.None -> query
  }
  let query = case input.position {
    option.Some(v) -> rest.add_query(query, "position", v)
    option.None -> query
  }
  let query = case input.resource_owner {
    option.Some(v) ->
      rest.add_query(
        query,
        "resourceOwner",
        rest.enum_wire_value(encode_resource_owner_enum(v)),
      )
    option.None -> query
  }
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_domain_name_access_associations_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(DomainNameAccessAssociations, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_domain_name_access_associations_output("{}")
        _ -> decode_get_domain_name_access_associations_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_domain_names_input(input: GetDomainNamesRequest) -> String {
  json.to_string(encode_get_domain_names_request_struct(input))
}

pub fn decode_get_domain_names_input(
  body: String,
) -> Result(GetDomainNamesRequest, String) {
  case json.parse(body, decode_get_domain_names_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_domain_names_output(
  body: String,
) -> Result(DomainNames, String) {
  case json.parse(body, decode_domain_names_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_domain_names_body(
  _input: GetDomainNamesRequest,
) -> json.Json {
  json.object([])
}

pub fn build_get_domain_names_request(
  input: GetDomainNamesRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/domainnames"
  let query = ""
  let query = case input.limit {
    option.Some(v) -> rest.add_query(query, "limit", rest.int_to_query(v))
    option.None -> query
  }
  let query = case input.position {
    option.Some(v) -> rest.add_query(query, "position", v)
    option.None -> query
  }
  let query = case input.resource_owner {
    option.Some(v) ->
      rest.add_query(
        query,
        "resourceOwner",
        rest.enum_wire_value(encode_resource_owner_enum(v)),
      )
    option.None -> query
  }
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_domain_names_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(DomainNames, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_domain_names_output("{}")
        _ -> decode_get_domain_names_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_export_input(input: GetExportRequest) -> String {
  json.to_string(encode_get_export_request_struct(input))
}

pub fn decode_get_export_input(
  body: String,
) -> Result(GetExportRequest, String) {
  case json.parse(body, decode_get_export_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_export_output(
  body: String,
) -> Result(ExportResponse, String) {
  case json.parse(body, decode_export_response_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_export_body(_input: GetExportRequest) -> json.Json {
  json.object([])
}

pub fn build_get_export_request(
  input: GetExportRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/stages/{stageName}/exports/{exportType}"
  let path = case input.export_type {
    option.Some(v) -> rest.substitute_label(path, "exportType", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let path = case input.stage_name {
    option.Some(v) -> rest.substitute_label(path, "stageName", v, False)
    option.None -> path
  }
  let query = ""
  let query = case input.parameters {
    option.Some(m) -> rest.add_query_params(query, m)
    option.None -> query
  }
  let headers = dict.new()
  let headers = case input.accepts {
    option.Some(v) -> rest.maybe_set_header(headers, "Accept", v)
    option.None -> headers
  }
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_export_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(ExportResponse, String) {
  let payload = option.Some(body)
  Ok(ExportResponse(
    body: payload,
    content_disposition: rest.string_header(headers, "Content-Disposition"),
    content_type: rest.string_header(headers, "Content-Type"),
  ))
}

pub fn encode_get_gateway_response_input(
  input: GetGatewayResponseRequest,
) -> String {
  json.to_string(encode_get_gateway_response_request_struct(input))
}

pub fn decode_get_gateway_response_input(
  body: String,
) -> Result(GetGatewayResponseRequest, String) {
  case json.parse(body, decode_get_gateway_response_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_gateway_response_output(
  body: String,
) -> Result(GatewayResponse, String) {
  case json.parse(body, decode_gateway_response_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_gateway_response_body(
  _input: GetGatewayResponseRequest,
) -> json.Json {
  json.object([])
}

pub fn build_get_gateway_response_request(
  input: GetGatewayResponseRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/gatewayresponses/{responseType}"
  let path = case input.response_type {
    option.Some(v) ->
      rest.substitute_label(
        path,
        "responseType",
        rest.enum_wire_value(encode_gateway_response_type_enum(v)),
        False,
      )
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_gateway_response_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(GatewayResponse, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_gateway_response_output("{}")
        _ -> decode_get_gateway_response_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_gateway_responses_input(
  input: GetGatewayResponsesRequest,
) -> String {
  json.to_string(encode_get_gateway_responses_request_struct(input))
}

pub fn decode_get_gateway_responses_input(
  body: String,
) -> Result(GetGatewayResponsesRequest, String) {
  case json.parse(body, decode_get_gateway_responses_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_gateway_responses_output(
  body: String,
) -> Result(GatewayResponses, String) {
  case json.parse(body, decode_gateway_responses_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_gateway_responses_body(
  _input: GetGatewayResponsesRequest,
) -> json.Json {
  json.object([])
}

pub fn build_get_gateway_responses_request(
  input: GetGatewayResponsesRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/gatewayresponses"
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let query = case input.limit {
    option.Some(v) -> rest.add_query(query, "limit", rest.int_to_query(v))
    option.None -> query
  }
  let query = case input.position {
    option.Some(v) -> rest.add_query(query, "position", v)
    option.None -> query
  }
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_gateway_responses_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(GatewayResponses, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_gateway_responses_output("{}")
        _ -> decode_get_gateway_responses_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_integration_input(input: GetIntegrationRequest) -> String {
  json.to_string(encode_get_integration_request_struct(input))
}

pub fn decode_get_integration_input(
  body: String,
) -> Result(GetIntegrationRequest, String) {
  case json.parse(body, decode_get_integration_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_integration_output(
  body: String,
) -> Result(Integration, String) {
  case json.parse(body, decode_integration_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_integration_body(_input: GetIntegrationRequest) -> json.Json {
  json.object([])
}

pub fn build_get_integration_request(
  input: GetIntegrationRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path =
    "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration"
  let path = case input.http_method {
    option.Some(v) -> rest.substitute_label(path, "httpMethod", v, False)
    option.None -> path
  }
  let path = case input.resource_id {
    option.Some(v) -> rest.substitute_label(path, "resourceId", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_integration_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Integration, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_integration_output("{}")
        _ -> decode_get_integration_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_integration_response_input(
  input: GetIntegrationResponseRequest,
) -> String {
  json.to_string(encode_get_integration_response_request_struct(input))
}

pub fn decode_get_integration_response_input(
  body: String,
) -> Result(GetIntegrationResponseRequest, String) {
  case
    json.parse(body, decode_get_integration_response_request_struct_params())
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_integration_response_output(
  body: String,
) -> Result(IntegrationResponse, String) {
  case json.parse(body, decode_integration_response_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_integration_response_body(
  _input: GetIntegrationResponseRequest,
) -> json.Json {
  json.object([])
}

pub fn build_get_integration_response_request(
  input: GetIntegrationResponseRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path =
    "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration/responses/{statusCode}"
  let path = case input.http_method {
    option.Some(v) -> rest.substitute_label(path, "httpMethod", v, False)
    option.None -> path
  }
  let path = case input.resource_id {
    option.Some(v) -> rest.substitute_label(path, "resourceId", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let path = case input.status_code {
    option.Some(v) -> rest.substitute_label(path, "statusCode", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_integration_response_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(IntegrationResponse, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_integration_response_output("{}")
        _ -> decode_get_integration_response_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_method_input(input: GetMethodRequest) -> String {
  json.to_string(encode_get_method_request_struct(input))
}

pub fn decode_get_method_input(
  body: String,
) -> Result(GetMethodRequest, String) {
  case json.parse(body, decode_get_method_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_method_output(body: String) -> Result(Method, String) {
  case json.parse(body, decode_method_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_method_body(_input: GetMethodRequest) -> json.Json {
  json.object([])
}

pub fn build_get_method_request(
  input: GetMethodRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}"
  let path = case input.http_method {
    option.Some(v) -> rest.substitute_label(path, "httpMethod", v, False)
    option.None -> path
  }
  let path = case input.resource_id {
    option.Some(v) -> rest.substitute_label(path, "resourceId", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_method_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Method, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_method_output("{}")
        _ -> decode_get_method_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_method_response_input(
  input: GetMethodResponseRequest,
) -> String {
  json.to_string(encode_get_method_response_request_struct(input))
}

pub fn decode_get_method_response_input(
  body: String,
) -> Result(GetMethodResponseRequest, String) {
  case json.parse(body, decode_get_method_response_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_method_response_output(
  body: String,
) -> Result(MethodResponse, String) {
  case json.parse(body, decode_method_response_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_method_response_body(
  _input: GetMethodResponseRequest,
) -> json.Json {
  json.object([])
}

pub fn build_get_method_response_request(
  input: GetMethodResponseRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path =
    "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/responses/{statusCode}"
  let path = case input.http_method {
    option.Some(v) -> rest.substitute_label(path, "httpMethod", v, False)
    option.None -> path
  }
  let path = case input.resource_id {
    option.Some(v) -> rest.substitute_label(path, "resourceId", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let path = case input.status_code {
    option.Some(v) -> rest.substitute_label(path, "statusCode", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_method_response_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(MethodResponse, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_method_response_output("{}")
        _ -> decode_get_method_response_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_model_input(input: GetModelRequest) -> String {
  json.to_string(encode_get_model_request_struct(input))
}

pub fn decode_get_model_input(body: String) -> Result(GetModelRequest, String) {
  case json.parse(body, decode_get_model_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_model_output(body: String) -> Result(Model, String) {
  case json.parse(body, decode_model_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_model_body(_input: GetModelRequest) -> json.Json {
  json.object([])
}

pub fn build_get_model_request(
  input: GetModelRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/models/{modelName}"
  let path = case input.model_name {
    option.Some(v) -> rest.substitute_label(path, "modelName", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let query = case input.flatten {
    option.Some(v) -> rest.add_query(query, "flatten", rest.bool_to_query(v))
    option.None -> query
  }
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_model_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Model, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_model_output("{}")
        _ -> decode_get_model_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_models_input(input: GetModelsRequest) -> String {
  json.to_string(encode_get_models_request_struct(input))
}

pub fn decode_get_models_input(
  body: String,
) -> Result(GetModelsRequest, String) {
  case json.parse(body, decode_get_models_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_models_output(body: String) -> Result(Models, String) {
  case json.parse(body, decode_models_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_models_body(_input: GetModelsRequest) -> json.Json {
  json.object([])
}

pub fn build_get_models_request(
  input: GetModelsRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/models"
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let query = case input.limit {
    option.Some(v) -> rest.add_query(query, "limit", rest.int_to_query(v))
    option.None -> query
  }
  let query = case input.position {
    option.Some(v) -> rest.add_query(query, "position", v)
    option.None -> query
  }
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_models_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Models, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_models_output("{}")
        _ -> decode_get_models_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_model_template_input(
  input: GetModelTemplateRequest,
) -> String {
  json.to_string(encode_get_model_template_request_struct(input))
}

pub fn decode_get_model_template_input(
  body: String,
) -> Result(GetModelTemplateRequest, String) {
  case json.parse(body, decode_get_model_template_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_model_template_output(
  body: String,
) -> Result(Template, String) {
  case json.parse(body, decode_template_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_model_template_body(
  _input: GetModelTemplateRequest,
) -> json.Json {
  json.object([])
}

pub fn build_get_model_template_request(
  input: GetModelTemplateRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/models/{modelName}/default_template"
  let path = case input.model_name {
    option.Some(v) -> rest.substitute_label(path, "modelName", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_model_template_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Template, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_model_template_output("{}")
        _ -> decode_get_model_template_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_request_validator_input(
  input: GetRequestValidatorRequest,
) -> String {
  json.to_string(encode_get_request_validator_request_struct(input))
}

pub fn decode_get_request_validator_input(
  body: String,
) -> Result(GetRequestValidatorRequest, String) {
  case json.parse(body, decode_get_request_validator_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_request_validator_output(
  body: String,
) -> Result(RequestValidator, String) {
  case json.parse(body, decode_request_validator_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_request_validator_body(
  _input: GetRequestValidatorRequest,
) -> json.Json {
  json.object([])
}

pub fn build_get_request_validator_request(
  input: GetRequestValidatorRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/requestvalidators/{requestValidatorId}"
  let path = case input.request_validator_id {
    option.Some(v) ->
      rest.substitute_label(path, "requestValidatorId", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_request_validator_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(RequestValidator, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_request_validator_output("{}")
        _ -> decode_get_request_validator_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_request_validators_input(
  input: GetRequestValidatorsRequest,
) -> String {
  json.to_string(encode_get_request_validators_request_struct(input))
}

pub fn decode_get_request_validators_input(
  body: String,
) -> Result(GetRequestValidatorsRequest, String) {
  case json.parse(body, decode_get_request_validators_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_request_validators_output(
  body: String,
) -> Result(RequestValidators, String) {
  case json.parse(body, decode_request_validators_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_request_validators_body(
  _input: GetRequestValidatorsRequest,
) -> json.Json {
  json.object([])
}

pub fn build_get_request_validators_request(
  input: GetRequestValidatorsRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/requestvalidators"
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let query = case input.limit {
    option.Some(v) -> rest.add_query(query, "limit", rest.int_to_query(v))
    option.None -> query
  }
  let query = case input.position {
    option.Some(v) -> rest.add_query(query, "position", v)
    option.None -> query
  }
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_request_validators_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(RequestValidators, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_request_validators_output("{}")
        _ -> decode_get_request_validators_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_resource_input(input: GetResourceRequest) -> String {
  json.to_string(encode_get_resource_request_struct(input))
}

pub fn decode_get_resource_input(
  body: String,
) -> Result(GetResourceRequest, String) {
  case json.parse(body, decode_get_resource_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_resource_output(body: String) -> Result(Resource, String) {
  case json.parse(body, decode_resource_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_resource_body(_input: GetResourceRequest) -> json.Json {
  json.object([])
}

pub fn build_get_resource_request(
  input: GetResourceRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/resources/{resourceId}"
  let path = case input.resource_id {
    option.Some(v) -> rest.substitute_label(path, "resourceId", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let query = case input.embed {
    option.Some(xs) ->
      list.fold(xs, query, fn(q, item) {
        {
          let v = item
          rest.add_query(q, "embed", v)
        }
      })
    option.None -> query
  }
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_resource_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Resource, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_resource_output("{}")
        _ -> decode_get_resource_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_resources_input(input: GetResourcesRequest) -> String {
  json.to_string(encode_get_resources_request_struct(input))
}

pub fn decode_get_resources_input(
  body: String,
) -> Result(GetResourcesRequest, String) {
  case json.parse(body, decode_get_resources_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_resources_output(body: String) -> Result(Resources, String) {
  case json.parse(body, decode_resources_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_resources_body(_input: GetResourcesRequest) -> json.Json {
  json.object([])
}

pub fn build_get_resources_request(
  input: GetResourcesRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/resources"
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let query = case input.embed {
    option.Some(xs) ->
      list.fold(xs, query, fn(q, item) {
        {
          let v = item
          rest.add_query(q, "embed", v)
        }
      })
    option.None -> query
  }
  let query = case input.limit {
    option.Some(v) -> rest.add_query(query, "limit", rest.int_to_query(v))
    option.None -> query
  }
  let query = case input.position {
    option.Some(v) -> rest.add_query(query, "position", v)
    option.None -> query
  }
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_resources_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Resources, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_resources_output("{}")
        _ -> decode_get_resources_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_rest_api_input(input: GetRestApiRequest) -> String {
  json.to_string(encode_get_rest_api_request_struct(input))
}

pub fn decode_get_rest_api_input(
  body: String,
) -> Result(GetRestApiRequest, String) {
  case json.parse(body, decode_get_rest_api_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_rest_api_output(body: String) -> Result(RestApi, String) {
  case json.parse(body, decode_rest_api_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_rest_api_body(_input: GetRestApiRequest) -> json.Json {
  json.object([])
}

pub fn build_get_rest_api_request(
  input: GetRestApiRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}"
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_rest_api_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(RestApi, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_rest_api_output("{}")
        _ -> decode_get_rest_api_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_rest_apis_input(input: GetRestApisRequest) -> String {
  json.to_string(encode_get_rest_apis_request_struct(input))
}

pub fn decode_get_rest_apis_input(
  body: String,
) -> Result(GetRestApisRequest, String) {
  case json.parse(body, decode_get_rest_apis_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_rest_apis_output(body: String) -> Result(RestApis, String) {
  case json.parse(body, decode_rest_apis_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_rest_apis_body(_input: GetRestApisRequest) -> json.Json {
  json.object([])
}

pub fn build_get_rest_apis_request(
  input: GetRestApisRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis"
  let query = ""
  let query = case input.limit {
    option.Some(v) -> rest.add_query(query, "limit", rest.int_to_query(v))
    option.None -> query
  }
  let query = case input.position {
    option.Some(v) -> rest.add_query(query, "position", v)
    option.None -> query
  }
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_rest_apis_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(RestApis, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_rest_apis_output("{}")
        _ -> decode_get_rest_apis_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_sdk_input(input: GetSdkRequest) -> String {
  json.to_string(encode_get_sdk_request_struct(input))
}

pub fn decode_get_sdk_input(body: String) -> Result(GetSdkRequest, String) {
  case json.parse(body, decode_get_sdk_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_sdk_output(body: String) -> Result(SdkResponse, String) {
  case json.parse(body, decode_sdk_response_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_sdk_body(_input: GetSdkRequest) -> json.Json {
  json.object([])
}

pub fn build_get_sdk_request(
  input: GetSdkRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/stages/{stageName}/sdks/{sdkType}"
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let path = case input.sdk_type {
    option.Some(v) -> rest.substitute_label(path, "sdkType", v, False)
    option.None -> path
  }
  let path = case input.stage_name {
    option.Some(v) -> rest.substitute_label(path, "stageName", v, False)
    option.None -> path
  }
  let query = ""
  let query = case input.parameters {
    option.Some(m) -> rest.add_query_params(query, m)
    option.None -> query
  }
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_sdk_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(SdkResponse, String) {
  let payload = option.Some(body)
  Ok(SdkResponse(
    body: payload,
    content_disposition: rest.string_header(headers, "Content-Disposition"),
    content_type: rest.string_header(headers, "Content-Type"),
  ))
}

pub fn encode_get_sdk_type_input(input: GetSdkTypeRequest) -> String {
  json.to_string(encode_get_sdk_type_request_struct(input))
}

pub fn decode_get_sdk_type_input(
  body: String,
) -> Result(GetSdkTypeRequest, String) {
  case json.parse(body, decode_get_sdk_type_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_sdk_type_output(body: String) -> Result(SdkType, String) {
  case json.parse(body, decode_sdk_type_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_sdk_type_body(_input: GetSdkTypeRequest) -> json.Json {
  json.object([])
}

pub fn build_get_sdk_type_request(
  input: GetSdkTypeRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/sdktypes/{id}"
  let path = case input.id {
    option.Some(v) -> rest.substitute_label(path, "id", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_sdk_type_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(SdkType, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_sdk_type_output("{}")
        _ -> decode_get_sdk_type_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_sdk_types_input(input: GetSdkTypesRequest) -> String {
  json.to_string(encode_get_sdk_types_request_struct(input))
}

pub fn decode_get_sdk_types_input(
  body: String,
) -> Result(GetSdkTypesRequest, String) {
  case json.parse(body, decode_get_sdk_types_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_sdk_types_output(body: String) -> Result(SdkTypes, String) {
  case json.parse(body, decode_sdk_types_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_sdk_types_body(_input: GetSdkTypesRequest) -> json.Json {
  json.object([])
}

pub fn build_get_sdk_types_request(
  input: GetSdkTypesRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/sdktypes"
  let query = ""
  let query = case input.limit {
    option.Some(v) -> rest.add_query(query, "limit", rest.int_to_query(v))
    option.None -> query
  }
  let query = case input.position {
    option.Some(v) -> rest.add_query(query, "position", v)
    option.None -> query
  }
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_sdk_types_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(SdkTypes, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_sdk_types_output("{}")
        _ -> decode_get_sdk_types_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_stage_input(input: GetStageRequest) -> String {
  json.to_string(encode_get_stage_request_struct(input))
}

pub fn decode_get_stage_input(body: String) -> Result(GetStageRequest, String) {
  case json.parse(body, decode_get_stage_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_stage_output(body: String) -> Result(Stage, String) {
  case json.parse(body, decode_stage_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_stage_body(_input: GetStageRequest) -> json.Json {
  json.object([])
}

pub fn build_get_stage_request(
  input: GetStageRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/stages/{stageName}"
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let path = case input.stage_name {
    option.Some(v) -> rest.substitute_label(path, "stageName", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_stage_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Stage, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_stage_output("{}")
        _ -> decode_get_stage_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_stages_input(input: GetStagesRequest) -> String {
  json.to_string(encode_get_stages_request_struct(input))
}

pub fn decode_get_stages_input(
  body: String,
) -> Result(GetStagesRequest, String) {
  case json.parse(body, decode_get_stages_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_stages_output(body: String) -> Result(Stages, String) {
  case json.parse(body, decode_stages_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_stages_body(_input: GetStagesRequest) -> json.Json {
  json.object([])
}

pub fn build_get_stages_request(
  input: GetStagesRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/stages"
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let query = case input.deployment_id {
    option.Some(v) -> rest.add_query(query, "deploymentId", v)
    option.None -> query
  }
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_stages_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Stages, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_stages_output("{}")
        _ -> decode_get_stages_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_tags_input(input: GetTagsRequest) -> String {
  json.to_string(encode_get_tags_request_struct(input))
}

pub fn decode_get_tags_input(body: String) -> Result(GetTagsRequest, String) {
  case json.parse(body, decode_get_tags_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_tags_output(body: String) -> Result(Tags, String) {
  case json.parse(body, decode_tags_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_tags_body(_input: GetTagsRequest) -> json.Json {
  json.object([])
}

pub fn build_get_tags_request(
  input: GetTagsRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/tags/{resourceArn}"
  let path = case input.resource_arn {
    option.Some(v) -> rest.substitute_label(path, "resourceArn", v, False)
    option.None -> path
  }
  let query = ""
  let query = case input.limit {
    option.Some(v) -> rest.add_query(query, "limit", rest.int_to_query(v))
    option.None -> query
  }
  let query = case input.position {
    option.Some(v) -> rest.add_query(query, "position", v)
    option.None -> query
  }
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_tags_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Tags, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_tags_output("{}")
        _ -> decode_get_tags_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_usage_input(input: GetUsageRequest) -> String {
  json.to_string(encode_get_usage_request_struct(input))
}

pub fn decode_get_usage_input(body: String) -> Result(GetUsageRequest, String) {
  case json.parse(body, decode_get_usage_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_usage_output(body: String) -> Result(Usage, String) {
  case json.parse(body, decode_usage_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_usage_body(_input: GetUsageRequest) -> json.Json {
  json.object([])
}

pub fn build_get_usage_request(
  input: GetUsageRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/usageplans/{usagePlanId}/usage"
  let path = case input.usage_plan_id {
    option.Some(v) -> rest.substitute_label(path, "usagePlanId", v, False)
    option.None -> path
  }
  let query = ""
  let query = case input.end_date {
    option.Some(v) -> rest.add_query(query, "endDate", v)
    option.None -> query
  }
  let query = case input.key_id {
    option.Some(v) -> rest.add_query(query, "keyId", v)
    option.None -> query
  }
  let query = case input.limit {
    option.Some(v) -> rest.add_query(query, "limit", rest.int_to_query(v))
    option.None -> query
  }
  let query = case input.position {
    option.Some(v) -> rest.add_query(query, "position", v)
    option.None -> query
  }
  let query = case input.start_date {
    option.Some(v) -> rest.add_query(query, "startDate", v)
    option.None -> query
  }
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_usage_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Usage, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_usage_output("{}")
        _ -> decode_get_usage_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_usage_plan_input(input: GetUsagePlanRequest) -> String {
  json.to_string(encode_get_usage_plan_request_struct(input))
}

pub fn decode_get_usage_plan_input(
  body: String,
) -> Result(GetUsagePlanRequest, String) {
  case json.parse(body, decode_get_usage_plan_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_usage_plan_output(body: String) -> Result(UsagePlan, String) {
  case json.parse(body, decode_usage_plan_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_usage_plan_body(_input: GetUsagePlanRequest) -> json.Json {
  json.object([])
}

pub fn build_get_usage_plan_request(
  input: GetUsagePlanRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/usageplans/{usagePlanId}"
  let path = case input.usage_plan_id {
    option.Some(v) -> rest.substitute_label(path, "usagePlanId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_usage_plan_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(UsagePlan, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_usage_plan_output("{}")
        _ -> decode_get_usage_plan_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_usage_plan_key_input(
  input: GetUsagePlanKeyRequest,
) -> String {
  json.to_string(encode_get_usage_plan_key_request_struct(input))
}

pub fn decode_get_usage_plan_key_input(
  body: String,
) -> Result(GetUsagePlanKeyRequest, String) {
  case json.parse(body, decode_get_usage_plan_key_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_usage_plan_key_output(
  body: String,
) -> Result(UsagePlanKey, String) {
  case json.parse(body, decode_usage_plan_key_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_usage_plan_key_body(
  _input: GetUsagePlanKeyRequest,
) -> json.Json {
  json.object([])
}

pub fn build_get_usage_plan_key_request(
  input: GetUsagePlanKeyRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/usageplans/{usagePlanId}/keys/{keyId}"
  let path = case input.key_id {
    option.Some(v) -> rest.substitute_label(path, "keyId", v, False)
    option.None -> path
  }
  let path = case input.usage_plan_id {
    option.Some(v) -> rest.substitute_label(path, "usagePlanId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_usage_plan_key_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(UsagePlanKey, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_usage_plan_key_output("{}")
        _ -> decode_get_usage_plan_key_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_usage_plan_keys_input(
  input: GetUsagePlanKeysRequest,
) -> String {
  json.to_string(encode_get_usage_plan_keys_request_struct(input))
}

pub fn decode_get_usage_plan_keys_input(
  body: String,
) -> Result(GetUsagePlanKeysRequest, String) {
  case json.parse(body, decode_get_usage_plan_keys_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_usage_plan_keys_output(
  body: String,
) -> Result(UsagePlanKeys, String) {
  case json.parse(body, decode_usage_plan_keys_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_usage_plan_keys_body(
  _input: GetUsagePlanKeysRequest,
) -> json.Json {
  json.object([])
}

pub fn build_get_usage_plan_keys_request(
  input: GetUsagePlanKeysRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/usageplans/{usagePlanId}/keys"
  let path = case input.usage_plan_id {
    option.Some(v) -> rest.substitute_label(path, "usagePlanId", v, False)
    option.None -> path
  }
  let query = ""
  let query = case input.limit {
    option.Some(v) -> rest.add_query(query, "limit", rest.int_to_query(v))
    option.None -> query
  }
  let query = case input.name_query {
    option.Some(v) -> rest.add_query(query, "name", v)
    option.None -> query
  }
  let query = case input.position {
    option.Some(v) -> rest.add_query(query, "position", v)
    option.None -> query
  }
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_usage_plan_keys_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(UsagePlanKeys, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_usage_plan_keys_output("{}")
        _ -> decode_get_usage_plan_keys_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_usage_plans_input(input: GetUsagePlansRequest) -> String {
  json.to_string(encode_get_usage_plans_request_struct(input))
}

pub fn decode_get_usage_plans_input(
  body: String,
) -> Result(GetUsagePlansRequest, String) {
  case json.parse(body, decode_get_usage_plans_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_usage_plans_output(
  body: String,
) -> Result(UsagePlans, String) {
  case json.parse(body, decode_usage_plans_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_usage_plans_body(_input: GetUsagePlansRequest) -> json.Json {
  json.object([])
}

pub fn build_get_usage_plans_request(
  input: GetUsagePlansRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/usageplans"
  let query = ""
  let query = case input.key_id {
    option.Some(v) -> rest.add_query(query, "keyId", v)
    option.None -> query
  }
  let query = case input.limit {
    option.Some(v) -> rest.add_query(query, "limit", rest.int_to_query(v))
    option.None -> query
  }
  let query = case input.position {
    option.Some(v) -> rest.add_query(query, "position", v)
    option.None -> query
  }
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_usage_plans_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(UsagePlans, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_usage_plans_output("{}")
        _ -> decode_get_usage_plans_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_vpc_link_input(input: GetVpcLinkRequest) -> String {
  json.to_string(encode_get_vpc_link_request_struct(input))
}

pub fn decode_get_vpc_link_input(
  body: String,
) -> Result(GetVpcLinkRequest, String) {
  case json.parse(body, decode_get_vpc_link_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_vpc_link_output(body: String) -> Result(VpcLink, String) {
  case json.parse(body, decode_vpc_link_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_vpc_link_body(_input: GetVpcLinkRequest) -> json.Json {
  json.object([])
}

pub fn build_get_vpc_link_request(
  input: GetVpcLinkRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/vpclinks/{vpcLinkId}"
  let path = case input.vpc_link_id {
    option.Some(v) -> rest.substitute_label(path, "vpcLinkId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_vpc_link_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(VpcLink, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_vpc_link_output("{}")
        _ -> decode_get_vpc_link_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_get_vpc_links_input(input: GetVpcLinksRequest) -> String {
  json.to_string(encode_get_vpc_links_request_struct(input))
}

pub fn decode_get_vpc_links_input(
  body: String,
) -> Result(GetVpcLinksRequest, String) {
  case json.parse(body, decode_get_vpc_links_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_get_vpc_links_output(body: String) -> Result(VpcLinks, String) {
  case json.parse(body, decode_vpc_links_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_get_vpc_links_body(_input: GetVpcLinksRequest) -> json.Json {
  json.object([])
}

pub fn build_get_vpc_links_request(
  input: GetVpcLinksRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/vpclinks"
  let query = ""
  let query = case input.limit {
    option.Some(v) -> rest.add_query(query, "limit", rest.int_to_query(v))
    option.None -> query
  }
  let query = case input.position {
    option.Some(v) -> rest.add_query(query, "position", v)
    option.None -> query
  }
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("GET", path, headers, body)
}

pub fn parse_get_vpc_links_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(VpcLinks, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_get_vpc_links_output("{}")
        _ -> decode_get_vpc_links_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_import_api_keys_input(input: ImportApiKeysRequest) -> String {
  json.to_string(encode_import_api_keys_request_struct(input))
}

pub fn decode_import_api_keys_input(
  body: String,
) -> Result(ImportApiKeysRequest, String) {
  case json.parse(body, decode_import_api_keys_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_import_api_keys_output(
  body: String,
) -> Result(ApiKeyIds, String) {
  case json.parse(body, decode_api_key_ids_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_import_api_keys_body(_input: ImportApiKeysRequest) -> json.Json {
  json.object([])
}

pub fn build_import_api_keys_request(
  input: ImportApiKeysRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/apikeys?mode=import"
  let query = ""
  let query = case input.fail_on_warnings {
    option.Some(v) ->
      rest.add_query(query, "failonwarnings", rest.bool_to_query(v))
    option.None -> query
  }
  let query = case input.format {
    option.Some(v) ->
      rest.add_query(
        query,
        "format",
        rest.enum_wire_value(encode_api_keys_format_enum(v)),
      )
    option.None -> query
  }
  let headers = dict.new()
  let body = case input.body {
    option.Some(v) -> v
    option.None -> <<>>
  }
  let content_type = "application/octet-stream"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("POST", path, headers, body)
}

pub fn parse_import_api_keys_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(ApiKeyIds, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_import_api_keys_output("{}")
        _ -> decode_import_api_keys_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_import_documentation_parts_input(
  input: ImportDocumentationPartsRequest,
) -> String {
  json.to_string(encode_import_documentation_parts_request_struct(input))
}

pub fn decode_import_documentation_parts_input(
  body: String,
) -> Result(ImportDocumentationPartsRequest, String) {
  case
    json.parse(body, decode_import_documentation_parts_request_struct_params())
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_import_documentation_parts_output(
  body: String,
) -> Result(DocumentationPartIds, String) {
  case json.parse(body, decode_documentation_part_ids_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_import_documentation_parts_body(
  _input: ImportDocumentationPartsRequest,
) -> json.Json {
  json.object([])
}

pub fn build_import_documentation_parts_request(
  input: ImportDocumentationPartsRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/documentation/parts"
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let query = case input.fail_on_warnings {
    option.Some(v) ->
      rest.add_query(query, "failonwarnings", rest.bool_to_query(v))
    option.None -> query
  }
  let query = case input.mode {
    option.Some(v) ->
      rest.add_query(
        query,
        "mode",
        rest.enum_wire_value(encode_put_mode_enum(v)),
      )
    option.None -> query
  }
  let headers = dict.new()
  let body = case input.body {
    option.Some(v) -> v
    option.None -> <<>>
  }
  let content_type = "application/octet-stream"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("PUT", path, headers, body)
}

pub fn parse_import_documentation_parts_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(DocumentationPartIds, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_import_documentation_parts_output("{}")
        _ -> decode_import_documentation_parts_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_import_rest_api_input(input: ImportRestApiRequest) -> String {
  json.to_string(encode_import_rest_api_request_struct(input))
}

pub fn decode_import_rest_api_input(
  body: String,
) -> Result(ImportRestApiRequest, String) {
  case json.parse(body, decode_import_rest_api_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_import_rest_api_output(body: String) -> Result(RestApi, String) {
  case json.parse(body, decode_rest_api_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_import_rest_api_body(_input: ImportRestApiRequest) -> json.Json {
  json.object([])
}

pub fn build_import_rest_api_request(
  input: ImportRestApiRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis?mode=import"
  let query = ""
  let query = case input.fail_on_warnings {
    option.Some(v) ->
      rest.add_query(query, "failonwarnings", rest.bool_to_query(v))
    option.None -> query
  }
  let query = case input.parameters {
    option.Some(m) -> rest.add_query_params(query, m)
    option.None -> query
  }
  let headers = dict.new()
  let body = case input.body {
    option.Some(v) -> v
    option.None -> <<>>
  }
  let content_type = "application/octet-stream"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("POST", path, headers, body)
}

pub fn parse_import_rest_api_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(RestApi, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_import_rest_api_output("{}")
        _ -> decode_import_rest_api_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_put_gateway_response_input(
  input: PutGatewayResponseRequest,
) -> String {
  json.to_string(encode_put_gateway_response_request_struct(input))
}

pub fn decode_put_gateway_response_input(
  body: String,
) -> Result(PutGatewayResponseRequest, String) {
  case json.parse(body, decode_put_gateway_response_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_put_gateway_response_output(
  body: String,
) -> Result(GatewayResponse, String) {
  case json.parse(body, decode_gateway_response_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_put_gateway_response_body(
  input: PutGatewayResponseRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.response_parameters {
    option.Some(v) -> [
      #(
        "responseParameters",
        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.response_templates {
    option.Some(v) -> [
      #(
        "responseTemplates",
        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.status_code {
    option.Some(v) -> [#("statusCode", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_put_gateway_response_request(
  input: PutGatewayResponseRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/gatewayresponses/{responseType}"
  let path = case input.response_type {
    option.Some(v) ->
      rest.substitute_label(
        path,
        "responseType",
        rest.enum_wire_value(encode_gateway_response_type_enum(v)),
        False,
      )
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body_json = encode_put_gateway_response_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("PUT", path, headers, body)
}

pub fn parse_put_gateway_response_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(GatewayResponse, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_put_gateway_response_output("{}")
        _ -> decode_put_gateway_response_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_put_integration_input(input: PutIntegrationRequest) -> String {
  json.to_string(encode_put_integration_request_struct(input))
}

pub fn decode_put_integration_input(
  body: String,
) -> Result(PutIntegrationRequest, String) {
  case json.parse(body, decode_put_integration_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_put_integration_output(
  body: String,
) -> Result(Integration, String) {
  case json.parse(body, decode_integration_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_put_integration_body(input: PutIntegrationRequest) -> json.Json {
  let pairs = []
  let pairs = case input.cache_key_parameters {
    option.Some(v) -> [
      #("cacheKeyParameters", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.cache_namespace {
    option.Some(v) -> [#("cacheNamespace", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.connection_id {
    option.Some(v) -> [#("connectionId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.connection_type {
    option.Some(v) -> [
      #("connectionType", encode_connection_type_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.content_handling {
    option.Some(v) -> [
      #("contentHandling", encode_content_handling_strategy_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.credentials {
    option.Some(v) -> [#("credentials", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.integration_http_method {
    option.Some(v) -> [#("httpMethod", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.integration_target {
    option.Some(v) -> [#("integrationTarget", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.passthrough_behavior {
    option.Some(v) -> [#("passthroughBehavior", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.request_parameters {
    option.Some(v) -> [
      #(
        "requestParameters",
        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.request_templates {
    option.Some(v) -> [
      #(
        "requestTemplates",
        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.response_transfer_mode {
    option.Some(v) -> [
      #("responseTransferMode", encode_response_transfer_mode_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.timeout_in_millis {
    option.Some(v) -> [#("timeoutInMillis", json.int(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.tls_config {
    option.Some(v) -> [#("tlsConfig", encode_tls_config_struct(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.type_ {
    option.Some(v) -> [#("type", encode_integration_type_enum(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.uri {
    option.Some(v) -> [#("uri", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_put_integration_request(
  input: PutIntegrationRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path =
    "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration"
  let path = case input.http_method {
    option.Some(v) -> rest.substitute_label(path, "requestHttpMethod", v, False)
    option.None -> path
  }
  let path = case input.resource_id {
    option.Some(v) -> rest.substitute_label(path, "resourceId", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body_json = encode_put_integration_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("PUT", path, headers, body)
}

pub fn parse_put_integration_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Integration, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_put_integration_output("{}")
        _ -> decode_put_integration_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_put_integration_response_input(
  input: PutIntegrationResponseRequest,
) -> String {
  json.to_string(encode_put_integration_response_request_struct(input))
}

pub fn decode_put_integration_response_input(
  body: String,
) -> Result(PutIntegrationResponseRequest, String) {
  case
    json.parse(body, decode_put_integration_response_request_struct_params())
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_put_integration_response_output(
  body: String,
) -> Result(IntegrationResponse, String) {
  case json.parse(body, decode_integration_response_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_put_integration_response_body(
  input: PutIntegrationResponseRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.content_handling {
    option.Some(v) -> [
      #("contentHandling", encode_content_handling_strategy_enum(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.response_parameters {
    option.Some(v) -> [
      #(
        "responseParameters",
        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.response_templates {
    option.Some(v) -> [
      #(
        "responseTemplates",
        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.selection_pattern {
    option.Some(v) -> [#("selectionPattern", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_put_integration_response_request(
  input: PutIntegrationResponseRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path =
    "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration/responses/{statusCode}"
  let path = case input.http_method {
    option.Some(v) -> rest.substitute_label(path, "httpMethod", v, False)
    option.None -> path
  }
  let path = case input.resource_id {
    option.Some(v) -> rest.substitute_label(path, "resourceId", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let path = case input.status_code {
    option.Some(v) -> rest.substitute_label(path, "statusCode", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body_json = encode_put_integration_response_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("PUT", path, headers, body)
}

pub fn parse_put_integration_response_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(IntegrationResponse, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_put_integration_response_output("{}")
        _ -> decode_put_integration_response_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_put_method_input(input: PutMethodRequest) -> String {
  json.to_string(encode_put_method_request_struct(input))
}

pub fn decode_put_method_input(
  body: String,
) -> Result(PutMethodRequest, String) {
  case json.parse(body, decode_put_method_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_put_method_output(body: String) -> Result(Method, String) {
  case json.parse(body, decode_method_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_put_method_body(input: PutMethodRequest) -> json.Json {
  let pairs = []
  let pairs = case input.api_key_required {
    option.Some(v) -> [#("apiKeyRequired", json.bool(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.authorization_scopes {
    option.Some(v) -> [
      #("authorizationScopes", fn(xs) { json.array(xs, json.string) }(v)),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.authorization_type {
    option.Some(v) -> [#("authorizationType", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.authorizer_id {
    option.Some(v) -> [#("authorizerId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.operation_name {
    option.Some(v) -> [#("operationName", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.request_models {
    option.Some(v) -> [
      #(
        "requestModels",
        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.request_parameters {
    option.Some(v) -> [
      #(
        "requestParameters",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.bool(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.request_validator_id {
    option.Some(v) -> [#("requestValidatorId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_put_method_request(
  input: PutMethodRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}"
  let path = case input.http_method {
    option.Some(v) -> rest.substitute_label(path, "httpMethod", v, False)
    option.None -> path
  }
  let path = case input.resource_id {
    option.Some(v) -> rest.substitute_label(path, "resourceId", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body_json = encode_put_method_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("PUT", path, headers, body)
}

pub fn parse_put_method_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Method, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_put_method_output("{}")
        _ -> decode_put_method_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_put_method_response_input(
  input: PutMethodResponseRequest,
) -> String {
  json.to_string(encode_put_method_response_request_struct(input))
}

pub fn decode_put_method_response_input(
  body: String,
) -> Result(PutMethodResponseRequest, String) {
  case json.parse(body, decode_put_method_response_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_put_method_response_output(
  body: String,
) -> Result(MethodResponse, String) {
  case json.parse(body, decode_method_response_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_put_method_response_body(
  input: PutMethodResponseRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.response_models {
    option.Some(v) -> [
      #(
        "responseModels",
        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.response_parameters {
    option.Some(v) -> [
      #(
        "responseParameters",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.bool(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_put_method_response_request(
  input: PutMethodResponseRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path =
    "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/responses/{statusCode}"
  let path = case input.http_method {
    option.Some(v) -> rest.substitute_label(path, "httpMethod", v, False)
    option.None -> path
  }
  let path = case input.resource_id {
    option.Some(v) -> rest.substitute_label(path, "resourceId", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let path = case input.status_code {
    option.Some(v) -> rest.substitute_label(path, "statusCode", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body_json = encode_put_method_response_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("PUT", path, headers, body)
}

pub fn parse_put_method_response_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(MethodResponse, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_put_method_response_output("{}")
        _ -> decode_put_method_response_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_put_rest_api_input(input: PutRestApiRequest) -> String {
  json.to_string(encode_put_rest_api_request_struct(input))
}

pub fn decode_put_rest_api_input(
  body: String,
) -> Result(PutRestApiRequest, String) {
  case json.parse(body, decode_put_rest_api_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_put_rest_api_output(body: String) -> Result(RestApi, String) {
  case json.parse(body, decode_rest_api_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_put_rest_api_body(_input: PutRestApiRequest) -> json.Json {
  json.object([])
}

pub fn build_put_rest_api_request(
  input: PutRestApiRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}"
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let query = case input.fail_on_warnings {
    option.Some(v) ->
      rest.add_query(query, "failonwarnings", rest.bool_to_query(v))
    option.None -> query
  }
  let query = case input.mode {
    option.Some(v) ->
      rest.add_query(
        query,
        "mode",
        rest.enum_wire_value(encode_put_mode_enum(v)),
      )
    option.None -> query
  }
  let query = case input.parameters {
    option.Some(m) -> rest.add_query_params(query, m)
    option.None -> query
  }
  let headers = dict.new()
  let body = case input.body {
    option.Some(v) -> v
    option.None -> <<>>
  }
  let content_type = "application/octet-stream"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("PUT", path, headers, body)
}

pub fn parse_put_rest_api_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(RestApi, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_put_rest_api_output("{}")
        _ -> decode_put_rest_api_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type RejectDomainNameAccessAssociationOutput {
  RejectDomainNameAccessAssociationOutput
}

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

pub fn decode_reject_domain_name_access_association_output_struct() -> decode.Decoder(
  RejectDomainNameAccessAssociationOutput,
) {
  decode.success(RejectDomainNameAccessAssociationOutput)
}

pub fn encode_reject_domain_name_access_association_input(
  input: RejectDomainNameAccessAssociationRequest,
) -> String {
  json.to_string(encode_reject_domain_name_access_association_request_struct(
    input,
  ))
}

pub fn decode_reject_domain_name_access_association_input(
  body: String,
) -> Result(RejectDomainNameAccessAssociationRequest, String) {
  case
    json.parse(
      body,
      decode_reject_domain_name_access_association_request_struct_params(),
    )
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_reject_domain_name_access_association_output(
  body: String,
) -> Result(RejectDomainNameAccessAssociationOutput, String) {
  case
    json.parse(
      body,
      decode_reject_domain_name_access_association_output_struct(),
    )
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_reject_domain_name_access_association_body(
  _input: RejectDomainNameAccessAssociationRequest,
) -> json.Json {
  json.object([])
}

pub fn build_reject_domain_name_access_association_request(
  input: RejectDomainNameAccessAssociationRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/rejectdomainnameaccessassociations"
  let query = ""
  let query = case input.domain_name_access_association_arn {
    option.Some(v) -> rest.add_query(query, "domainNameAccessAssociationArn", v)
    option.None -> query
  }
  let query = case input.domain_name_arn {
    option.Some(v) -> rest.add_query(query, "domainNameArn", v)
    option.None -> query
  }
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("POST", path, headers, body)
}

pub fn parse_reject_domain_name_access_association_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  _body: BitArray,
) -> Result(RejectDomainNameAccessAssociationOutput, String) {
  Ok(RejectDomainNameAccessAssociationOutput)
}

pub type TagResourceOutput {
  TagResourceOutput
}

pub fn encode_tag_resource_output_struct(_v: TagResourceOutput) -> json.Json {
  json.object([])
}

pub fn decode_tag_resource_output_struct() -> decode.Decoder(TagResourceOutput) {
  decode.success(TagResourceOutput)
}

pub fn encode_tag_resource_input(input: TagResourceRequest) -> String {
  json.to_string(encode_tag_resource_request_struct(input))
}

pub fn decode_tag_resource_input(
  body: String,
) -> Result(TagResourceRequest, String) {
  case json.parse(body, decode_tag_resource_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

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 encode_tag_resource_body(input: TagResourceRequest) -> json.Json {
  let pairs = []
  let pairs = case input.tags {
    option.Some(v) -> [
      #(
        "tags",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_tag_resource_request(
  input: TagResourceRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/tags/{resourceArn}"
  let path = case input.resource_arn {
    option.Some(v) -> rest.substitute_label(path, "resourceArn", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body_json = encode_tag_resource_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("PUT", path, headers, body)
}

pub fn parse_tag_resource_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  _body: BitArray,
) -> Result(TagResourceOutput, String) {
  Ok(TagResourceOutput)
}

pub fn encode_test_invoke_authorizer_input(
  input: TestInvokeAuthorizerRequest,
) -> String {
  json.to_string(encode_test_invoke_authorizer_request_struct(input))
}

pub fn decode_test_invoke_authorizer_input(
  body: String,
) -> Result(TestInvokeAuthorizerRequest, String) {
  case json.parse(body, decode_test_invoke_authorizer_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_test_invoke_authorizer_output(
  body: String,
) -> Result(TestInvokeAuthorizerResponse, String) {
  case json.parse(body, decode_test_invoke_authorizer_response_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_test_invoke_authorizer_body(
  input: TestInvokeAuthorizerRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.additional_context {
    option.Some(v) -> [
      #(
        "additionalContext",
        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.body {
    option.Some(v) -> [#("body", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.headers {
    option.Some(v) -> [
      #(
        "headers",
        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.multi_value_headers {
    option.Some(v) -> [
      #(
        "multiValueHeaders",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, fn(xs) { json.array(xs, json.string) }(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.path_with_query_string {
    option.Some(v) -> [#("pathWithQueryString", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.stage_variables {
    option.Some(v) -> [
      #(
        "stageVariables",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_test_invoke_authorizer_request(
  input: TestInvokeAuthorizerRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/authorizers/{authorizerId}"
  let path = case input.authorizer_id {
    option.Some(v) -> rest.substitute_label(path, "authorizerId", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body_json = encode_test_invoke_authorizer_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("POST", path, headers, body)
}

pub fn parse_test_invoke_authorizer_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(TestInvokeAuthorizerResponse, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_test_invoke_authorizer_output("{}")
        _ -> decode_test_invoke_authorizer_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_test_invoke_method_input(
  input: TestInvokeMethodRequest,
) -> String {
  json.to_string(encode_test_invoke_method_request_struct(input))
}

pub fn decode_test_invoke_method_input(
  body: String,
) -> Result(TestInvokeMethodRequest, String) {
  case json.parse(body, decode_test_invoke_method_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_test_invoke_method_output(
  body: String,
) -> Result(TestInvokeMethodResponse, String) {
  case json.parse(body, decode_test_invoke_method_response_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_test_invoke_method_body(
  input: TestInvokeMethodRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.body {
    option.Some(v) -> [#("body", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.client_certificate_id {
    option.Some(v) -> [#("clientCertificateId", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.headers {
    option.Some(v) -> [
      #(
        "headers",
        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.multi_value_headers {
    option.Some(v) -> [
      #(
        "multiValueHeaders",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) {
              #(pair.0, fn(xs) { json.array(xs, json.string) }(pair.1))
            }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  let pairs = case input.path_with_query_string {
    option.Some(v) -> [#("pathWithQueryString", json.string(v)), ..pairs]
    option.None -> pairs
  }
  let pairs = case input.stage_variables {
    option.Some(v) -> [
      #(
        "stageVariables",
        fn(d) {
          json.object(
            dict.to_list(d)
            |> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
          )
        }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_test_invoke_method_request(
  input: TestInvokeMethodRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}"
  let path = case input.http_method {
    option.Some(v) -> rest.substitute_label(path, "httpMethod", v, False)
    option.None -> path
  }
  let path = case input.resource_id {
    option.Some(v) -> rest.substitute_label(path, "resourceId", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body_json = encode_test_invoke_method_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("POST", path, headers, body)
}

pub fn parse_test_invoke_method_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(TestInvokeMethodResponse, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_test_invoke_method_output("{}")
        _ -> decode_test_invoke_method_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type UntagResourceOutput {
  UntagResourceOutput
}

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

pub fn decode_untag_resource_output_struct() -> decode.Decoder(
  UntagResourceOutput,
) {
  decode.success(UntagResourceOutput)
}

pub fn encode_untag_resource_input(input: UntagResourceRequest) -> String {
  json.to_string(encode_untag_resource_request_struct(input))
}

pub fn decode_untag_resource_input(
  body: String,
) -> Result(UntagResourceRequest, String) {
  case json.parse(body, decode_untag_resource_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

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 encode_untag_resource_body(_input: UntagResourceRequest) -> json.Json {
  json.object([])
}

pub fn build_untag_resource_request(
  input: UntagResourceRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/tags/{resourceArn}"
  let path = case input.resource_arn {
    option.Some(v) -> rest.substitute_label(path, "resourceArn", v, False)
    option.None -> path
  }
  let query = ""
  let query = case input.tag_keys {
    option.Some(xs) ->
      list.fold(xs, query, fn(q, item) {
        {
          let v = item
          rest.add_query(q, "tagKeys", v)
        }
      })
    option.None -> query
  }
  let headers = dict.new()
  let body = <<>>
  let content_type = ""
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("DELETE", path, headers, body)
}

pub fn parse_untag_resource_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  _body: BitArray,
) -> Result(UntagResourceOutput, String) {
  Ok(UntagResourceOutput)
}

pub fn encode_update_account_input(input: UpdateAccountRequest) -> String {
  json.to_string(encode_update_account_request_struct(input))
}

pub fn decode_update_account_input(
  body: String,
) -> Result(UpdateAccountRequest, String) {
  case json.parse(body, decode_update_account_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_update_account_output(body: String) -> Result(Account, String) {
  case json.parse(body, decode_account_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_update_account_body(input: UpdateAccountRequest) -> json.Json {
  let pairs = []
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_update_account_request(
  input: UpdateAccountRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/account"
  let query = ""
  let headers = dict.new()
  let body_json = encode_update_account_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("PATCH", path, headers, body)
}

pub fn parse_update_account_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Account, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_update_account_output("{}")
        _ -> decode_update_account_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_update_api_key_input(input: UpdateApiKeyRequest) -> String {
  json.to_string(encode_update_api_key_request_struct(input))
}

pub fn decode_update_api_key_input(
  body: String,
) -> Result(UpdateApiKeyRequest, String) {
  case json.parse(body, decode_update_api_key_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_update_api_key_output(body: String) -> Result(ApiKey, String) {
  case json.parse(body, decode_api_key_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_update_api_key_body(input: UpdateApiKeyRequest) -> json.Json {
  let pairs = []
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_update_api_key_request(
  input: UpdateApiKeyRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/apikeys/{apiKey}"
  let path = case input.api_key {
    option.Some(v) -> rest.substitute_label(path, "apiKey", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body_json = encode_update_api_key_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("PATCH", path, headers, body)
}

pub fn parse_update_api_key_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(ApiKey, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_update_api_key_output("{}")
        _ -> decode_update_api_key_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_update_authorizer_input(
  input: UpdateAuthorizerRequest,
) -> String {
  json.to_string(encode_update_authorizer_request_struct(input))
}

pub fn decode_update_authorizer_input(
  body: String,
) -> Result(UpdateAuthorizerRequest, String) {
  case json.parse(body, decode_update_authorizer_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_update_authorizer_output(
  body: String,
) -> Result(Authorizer, String) {
  case json.parse(body, decode_authorizer_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_update_authorizer_body(
  input: UpdateAuthorizerRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_update_authorizer_request(
  input: UpdateAuthorizerRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/authorizers/{authorizerId}"
  let path = case input.authorizer_id {
    option.Some(v) -> rest.substitute_label(path, "authorizerId", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body_json = encode_update_authorizer_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("PATCH", path, headers, body)
}

pub fn parse_update_authorizer_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Authorizer, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_update_authorizer_output("{}")
        _ -> decode_update_authorizer_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_update_base_path_mapping_input(
  input: UpdateBasePathMappingRequest,
) -> String {
  json.to_string(encode_update_base_path_mapping_request_struct(input))
}

pub fn decode_update_base_path_mapping_input(
  body: String,
) -> Result(UpdateBasePathMappingRequest, String) {
  case
    json.parse(body, decode_update_base_path_mapping_request_struct_params())
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_update_base_path_mapping_output(
  body: String,
) -> Result(BasePathMapping, String) {
  case json.parse(body, decode_base_path_mapping_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_update_base_path_mapping_body(
  input: UpdateBasePathMappingRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_update_base_path_mapping_request(
  input: UpdateBasePathMappingRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/domainnames/{domainName}/basepathmappings/{basePath}"
  let path = case input.base_path {
    option.Some(v) -> rest.substitute_label(path, "basePath", v, False)
    option.None -> path
  }
  let path = case input.domain_name {
    option.Some(v) -> rest.substitute_label(path, "domainName", v, False)
    option.None -> path
  }
  let query = ""
  let query = case input.domain_name_id {
    option.Some(v) -> rest.add_query(query, "domainNameId", v)
    option.None -> query
  }
  let headers = dict.new()
  let body_json = encode_update_base_path_mapping_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("PATCH", path, headers, body)
}

pub fn parse_update_base_path_mapping_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(BasePathMapping, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_update_base_path_mapping_output("{}")
        _ -> decode_update_base_path_mapping_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_update_client_certificate_input(
  input: UpdateClientCertificateRequest,
) -> String {
  json.to_string(encode_update_client_certificate_request_struct(input))
}

pub fn decode_update_client_certificate_input(
  body: String,
) -> Result(UpdateClientCertificateRequest, String) {
  case
    json.parse(body, decode_update_client_certificate_request_struct_params())
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_update_client_certificate_output(
  body: String,
) -> Result(ClientCertificate, String) {
  case json.parse(body, decode_client_certificate_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_update_client_certificate_body(
  input: UpdateClientCertificateRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_update_client_certificate_request(
  input: UpdateClientCertificateRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/clientcertificates/{clientCertificateId}"
  let path = case input.client_certificate_id {
    option.Some(v) ->
      rest.substitute_label(path, "clientCertificateId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body_json = encode_update_client_certificate_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("PATCH", path, headers, body)
}

pub fn parse_update_client_certificate_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(ClientCertificate, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_update_client_certificate_output("{}")
        _ -> decode_update_client_certificate_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_update_deployment_input(
  input: UpdateDeploymentRequest,
) -> String {
  json.to_string(encode_update_deployment_request_struct(input))
}

pub fn decode_update_deployment_input(
  body: String,
) -> Result(UpdateDeploymentRequest, String) {
  case json.parse(body, decode_update_deployment_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_update_deployment_output(
  body: String,
) -> Result(Deployment, String) {
  case json.parse(body, decode_deployment_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_update_deployment_body(
  input: UpdateDeploymentRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_update_deployment_request(
  input: UpdateDeploymentRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/deployments/{deploymentId}"
  let path = case input.deployment_id {
    option.Some(v) -> rest.substitute_label(path, "deploymentId", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body_json = encode_update_deployment_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("PATCH", path, headers, body)
}

pub fn parse_update_deployment_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Deployment, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_update_deployment_output("{}")
        _ -> decode_update_deployment_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_update_documentation_part_input(
  input: UpdateDocumentationPartRequest,
) -> String {
  json.to_string(encode_update_documentation_part_request_struct(input))
}

pub fn decode_update_documentation_part_input(
  body: String,
) -> Result(UpdateDocumentationPartRequest, String) {
  case
    json.parse(body, decode_update_documentation_part_request_struct_params())
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_update_documentation_part_output(
  body: String,
) -> Result(DocumentationPart, String) {
  case json.parse(body, decode_documentation_part_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_update_documentation_part_body(
  input: UpdateDocumentationPartRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_update_documentation_part_request(
  input: UpdateDocumentationPartRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/documentation/parts/{documentationPartId}"
  let path = case input.documentation_part_id {
    option.Some(v) ->
      rest.substitute_label(path, "documentationPartId", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body_json = encode_update_documentation_part_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("PATCH", path, headers, body)
}

pub fn parse_update_documentation_part_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(DocumentationPart, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_update_documentation_part_output("{}")
        _ -> decode_update_documentation_part_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_update_documentation_version_input(
  input: UpdateDocumentationVersionRequest,
) -> String {
  json.to_string(encode_update_documentation_version_request_struct(input))
}

pub fn decode_update_documentation_version_input(
  body: String,
) -> Result(UpdateDocumentationVersionRequest, String) {
  case
    json.parse(
      body,
      decode_update_documentation_version_request_struct_params(),
    )
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_update_documentation_version_output(
  body: String,
) -> Result(DocumentationVersion, String) {
  case json.parse(body, decode_documentation_version_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_update_documentation_version_body(
  input: UpdateDocumentationVersionRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_update_documentation_version_request(
  input: UpdateDocumentationVersionRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path =
    "/restapis/{restApiId}/documentation/versions/{documentationVersion}"
  let path = case input.documentation_version {
    option.Some(v) ->
      rest.substitute_label(path, "documentationVersion", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body_json = encode_update_documentation_version_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("PATCH", path, headers, body)
}

pub fn parse_update_documentation_version_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(DocumentationVersion, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_update_documentation_version_output("{}")
        _ -> decode_update_documentation_version_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_update_domain_name_input(
  input: UpdateDomainNameRequest,
) -> String {
  json.to_string(encode_update_domain_name_request_struct(input))
}

pub fn decode_update_domain_name_input(
  body: String,
) -> Result(UpdateDomainNameRequest, String) {
  case json.parse(body, decode_update_domain_name_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_update_domain_name_output(
  body: String,
) -> Result(DomainName, String) {
  case json.parse(body, decode_domain_name_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_update_domain_name_body(
  input: UpdateDomainNameRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_update_domain_name_request(
  input: UpdateDomainNameRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/domainnames/{domainName}"
  let path = case input.domain_name {
    option.Some(v) -> rest.substitute_label(path, "domainName", v, False)
    option.None -> path
  }
  let query = ""
  let query = case input.domain_name_id {
    option.Some(v) -> rest.add_query(query, "domainNameId", v)
    option.None -> query
  }
  let headers = dict.new()
  let body_json = encode_update_domain_name_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("PATCH", path, headers, body)
}

pub fn parse_update_domain_name_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(DomainName, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_update_domain_name_output("{}")
        _ -> decode_update_domain_name_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_update_gateway_response_input(
  input: UpdateGatewayResponseRequest,
) -> String {
  json.to_string(encode_update_gateway_response_request_struct(input))
}

pub fn decode_update_gateway_response_input(
  body: String,
) -> Result(UpdateGatewayResponseRequest, String) {
  case
    json.parse(body, decode_update_gateway_response_request_struct_params())
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_update_gateway_response_output(
  body: String,
) -> Result(GatewayResponse, String) {
  case json.parse(body, decode_gateway_response_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_update_gateway_response_body(
  input: UpdateGatewayResponseRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_update_gateway_response_request(
  input: UpdateGatewayResponseRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/gatewayresponses/{responseType}"
  let path = case input.response_type {
    option.Some(v) ->
      rest.substitute_label(
        path,
        "responseType",
        rest.enum_wire_value(encode_gateway_response_type_enum(v)),
        False,
      )
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body_json = encode_update_gateway_response_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("PATCH", path, headers, body)
}

pub fn parse_update_gateway_response_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(GatewayResponse, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_update_gateway_response_output("{}")
        _ -> decode_update_gateway_response_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_update_integration_input(
  input: UpdateIntegrationRequest,
) -> String {
  json.to_string(encode_update_integration_request_struct(input))
}

pub fn decode_update_integration_input(
  body: String,
) -> Result(UpdateIntegrationRequest, String) {
  case json.parse(body, decode_update_integration_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_update_integration_output(
  body: String,
) -> Result(Integration, String) {
  case json.parse(body, decode_integration_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_update_integration_body(
  input: UpdateIntegrationRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_update_integration_request(
  input: UpdateIntegrationRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path =
    "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration"
  let path = case input.http_method {
    option.Some(v) -> rest.substitute_label(path, "httpMethod", v, False)
    option.None -> path
  }
  let path = case input.resource_id {
    option.Some(v) -> rest.substitute_label(path, "resourceId", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body_json = encode_update_integration_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("PATCH", path, headers, body)
}

pub fn parse_update_integration_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Integration, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_update_integration_output("{}")
        _ -> decode_update_integration_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_update_integration_response_input(
  input: UpdateIntegrationResponseRequest,
) -> String {
  json.to_string(encode_update_integration_response_request_struct(input))
}

pub fn decode_update_integration_response_input(
  body: String,
) -> Result(UpdateIntegrationResponseRequest, String) {
  case
    json.parse(body, decode_update_integration_response_request_struct_params())
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_update_integration_response_output(
  body: String,
) -> Result(IntegrationResponse, String) {
  case json.parse(body, decode_integration_response_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_update_integration_response_body(
  input: UpdateIntegrationResponseRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_update_integration_response_request(
  input: UpdateIntegrationResponseRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path =
    "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration/responses/{statusCode}"
  let path = case input.http_method {
    option.Some(v) -> rest.substitute_label(path, "httpMethod", v, False)
    option.None -> path
  }
  let path = case input.resource_id {
    option.Some(v) -> rest.substitute_label(path, "resourceId", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let path = case input.status_code {
    option.Some(v) -> rest.substitute_label(path, "statusCode", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body_json = encode_update_integration_response_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("PATCH", path, headers, body)
}

pub fn parse_update_integration_response_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(IntegrationResponse, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_update_integration_response_output("{}")
        _ -> decode_update_integration_response_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_update_method_input(input: UpdateMethodRequest) -> String {
  json.to_string(encode_update_method_request_struct(input))
}

pub fn decode_update_method_input(
  body: String,
) -> Result(UpdateMethodRequest, String) {
  case json.parse(body, decode_update_method_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_update_method_output(body: String) -> Result(Method, String) {
  case json.parse(body, decode_method_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_update_method_body(input: UpdateMethodRequest) -> json.Json {
  let pairs = []
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_update_method_request(
  input: UpdateMethodRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}"
  let path = case input.http_method {
    option.Some(v) -> rest.substitute_label(path, "httpMethod", v, False)
    option.None -> path
  }
  let path = case input.resource_id {
    option.Some(v) -> rest.substitute_label(path, "resourceId", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body_json = encode_update_method_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("PATCH", path, headers, body)
}

pub fn parse_update_method_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Method, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_update_method_output("{}")
        _ -> decode_update_method_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_update_method_response_input(
  input: UpdateMethodResponseRequest,
) -> String {
  json.to_string(encode_update_method_response_request_struct(input))
}

pub fn decode_update_method_response_input(
  body: String,
) -> Result(UpdateMethodResponseRequest, String) {
  case json.parse(body, decode_update_method_response_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_update_method_response_output(
  body: String,
) -> Result(MethodResponse, String) {
  case json.parse(body, decode_method_response_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_update_method_response_body(
  input: UpdateMethodResponseRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_update_method_response_request(
  input: UpdateMethodResponseRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path =
    "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/responses/{statusCode}"
  let path = case input.http_method {
    option.Some(v) -> rest.substitute_label(path, "httpMethod", v, False)
    option.None -> path
  }
  let path = case input.resource_id {
    option.Some(v) -> rest.substitute_label(path, "resourceId", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let path = case input.status_code {
    option.Some(v) -> rest.substitute_label(path, "statusCode", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body_json = encode_update_method_response_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("PATCH", path, headers, body)
}

pub fn parse_update_method_response_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(MethodResponse, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_update_method_response_output("{}")
        _ -> decode_update_method_response_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_update_model_input(input: UpdateModelRequest) -> String {
  json.to_string(encode_update_model_request_struct(input))
}

pub fn decode_update_model_input(
  body: String,
) -> Result(UpdateModelRequest, String) {
  case json.parse(body, decode_update_model_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_update_model_output(body: String) -> Result(Model, String) {
  case json.parse(body, decode_model_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_update_model_body(input: UpdateModelRequest) -> json.Json {
  let pairs = []
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_update_model_request(
  input: UpdateModelRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/models/{modelName}"
  let path = case input.model_name {
    option.Some(v) -> rest.substitute_label(path, "modelName", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body_json = encode_update_model_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("PATCH", path, headers, body)
}

pub fn parse_update_model_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Model, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_update_model_output("{}")
        _ -> decode_update_model_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_update_request_validator_input(
  input: UpdateRequestValidatorRequest,
) -> String {
  json.to_string(encode_update_request_validator_request_struct(input))
}

pub fn decode_update_request_validator_input(
  body: String,
) -> Result(UpdateRequestValidatorRequest, String) {
  case
    json.parse(body, decode_update_request_validator_request_struct_params())
  {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_update_request_validator_output(
  body: String,
) -> Result(RequestValidator, String) {
  case json.parse(body, decode_request_validator_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_update_request_validator_body(
  input: UpdateRequestValidatorRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_update_request_validator_request(
  input: UpdateRequestValidatorRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/requestvalidators/{requestValidatorId}"
  let path = case input.request_validator_id {
    option.Some(v) ->
      rest.substitute_label(path, "requestValidatorId", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body_json = encode_update_request_validator_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("PATCH", path, headers, body)
}

pub fn parse_update_request_validator_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(RequestValidator, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_update_request_validator_output("{}")
        _ -> decode_update_request_validator_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_update_resource_input(input: UpdateResourceRequest) -> String {
  json.to_string(encode_update_resource_request_struct(input))
}

pub fn decode_update_resource_input(
  body: String,
) -> Result(UpdateResourceRequest, String) {
  case json.parse(body, decode_update_resource_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_update_resource_output(body: String) -> Result(Resource, String) {
  case json.parse(body, decode_resource_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_update_resource_body(input: UpdateResourceRequest) -> json.Json {
  let pairs = []
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_update_resource_request(
  input: UpdateResourceRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/resources/{resourceId}"
  let path = case input.resource_id {
    option.Some(v) -> rest.substitute_label(path, "resourceId", v, False)
    option.None -> path
  }
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body_json = encode_update_resource_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("PATCH", path, headers, body)
}

pub fn parse_update_resource_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Resource, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_update_resource_output("{}")
        _ -> decode_update_resource_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_update_rest_api_input(input: UpdateRestApiRequest) -> String {
  json.to_string(encode_update_rest_api_request_struct(input))
}

pub fn decode_update_rest_api_input(
  body: String,
) -> Result(UpdateRestApiRequest, String) {
  case json.parse(body, decode_update_rest_api_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_update_rest_api_output(body: String) -> Result(RestApi, String) {
  case json.parse(body, decode_rest_api_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_update_rest_api_body(input: UpdateRestApiRequest) -> json.Json {
  let pairs = []
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_update_rest_api_request(
  input: UpdateRestApiRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}"
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body_json = encode_update_rest_api_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("PATCH", path, headers, body)
}

pub fn parse_update_rest_api_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(RestApi, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_update_rest_api_output("{}")
        _ -> decode_update_rest_api_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_update_stage_input(input: UpdateStageRequest) -> String {
  json.to_string(encode_update_stage_request_struct(input))
}

pub fn decode_update_stage_input(
  body: String,
) -> Result(UpdateStageRequest, String) {
  case json.parse(body, decode_update_stage_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_update_stage_output(body: String) -> Result(Stage, String) {
  case json.parse(body, decode_stage_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_update_stage_body(input: UpdateStageRequest) -> json.Json {
  let pairs = []
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_update_stage_request(
  input: UpdateStageRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/restapis/{restApiId}/stages/{stageName}"
  let path = case input.rest_api_id {
    option.Some(v) -> rest.substitute_label(path, "restApiId", v, False)
    option.None -> path
  }
  let path = case input.stage_name {
    option.Some(v) -> rest.substitute_label(path, "stageName", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body_json = encode_update_stage_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("PATCH", path, headers, body)
}

pub fn parse_update_stage_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Stage, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_update_stage_output("{}")
        _ -> decode_update_stage_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_update_usage_input(input: UpdateUsageRequest) -> String {
  json.to_string(encode_update_usage_request_struct(input))
}

pub fn decode_update_usage_input(
  body: String,
) -> Result(UpdateUsageRequest, String) {
  case json.parse(body, decode_update_usage_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_update_usage_output(body: String) -> Result(Usage, String) {
  case json.parse(body, decode_usage_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_update_usage_body(input: UpdateUsageRequest) -> json.Json {
  let pairs = []
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_update_usage_request(
  input: UpdateUsageRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/usageplans/{usagePlanId}/keys/{keyId}/usage"
  let path = case input.key_id {
    option.Some(v) -> rest.substitute_label(path, "keyId", v, False)
    option.None -> path
  }
  let path = case input.usage_plan_id {
    option.Some(v) -> rest.substitute_label(path, "usagePlanId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body_json = encode_update_usage_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("PATCH", path, headers, body)
}

pub fn parse_update_usage_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Usage, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_update_usage_output("{}")
        _ -> decode_update_usage_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_update_usage_plan_input(input: UpdateUsagePlanRequest) -> String {
  json.to_string(encode_update_usage_plan_request_struct(input))
}

pub fn decode_update_usage_plan_input(
  body: String,
) -> Result(UpdateUsagePlanRequest, String) {
  case json.parse(body, decode_update_usage_plan_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_update_usage_plan_output(
  body: String,
) -> Result(UsagePlan, String) {
  case json.parse(body, decode_usage_plan_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_update_usage_plan_body(
  input: UpdateUsagePlanRequest,
) -> json.Json {
  let pairs = []
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_update_usage_plan_request(
  input: UpdateUsagePlanRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/usageplans/{usagePlanId}"
  let path = case input.usage_plan_id {
    option.Some(v) -> rest.substitute_label(path, "usagePlanId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body_json = encode_update_usage_plan_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("PATCH", path, headers, body)
}

pub fn parse_update_usage_plan_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(UsagePlan, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_update_usage_plan_output("{}")
        _ -> decode_update_usage_plan_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub fn encode_update_vpc_link_input(input: UpdateVpcLinkRequest) -> String {
  json.to_string(encode_update_vpc_link_request_struct(input))
}

pub fn decode_update_vpc_link_input(
  body: String,
) -> Result(UpdateVpcLinkRequest, String) {
  case json.parse(body, decode_update_vpc_link_request_struct_params()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn decode_update_vpc_link_output(body: String) -> Result(VpcLink, String) {
  case json.parse(body, decode_vpc_link_struct()) {
    Ok(v) -> Ok(v)
    Error(_) -> Error("decode failed")
  }
}

pub fn encode_update_vpc_link_body(input: UpdateVpcLinkRequest) -> json.Json {
  let pairs = []
  let pairs = case input.patch_operations {
    option.Some(v) -> [
      #(
        "patchOperations",
        fn(xs) { json.array(xs, encode_patch_operation_struct) }(v),
      ),
      ..pairs
    ]
    option.None -> pairs
  }
  json.object(pairs)
}

pub fn build_update_vpc_link_request(
  input: UpdateVpcLinkRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
  let path = "/vpclinks/{vpcLinkId}"
  let path = case input.vpc_link_id {
    option.Some(v) -> rest.substitute_label(path, "vpcLinkId", v, False)
    option.None -> path
  }
  let query = ""
  let headers = dict.new()
  let body_json = encode_update_vpc_link_body(input)
  let body = bit_array.from_string(json.to_string(body_json))
  let content_type = "application/json"
  let headers = case content_type, dict.has_key(headers, "Content-Type") {
    "", _ -> headers
    _, True -> headers
    _, False -> dict.insert(headers, "Content-Type", content_type)
  }
  let headers = case content_type {
    "" -> headers
    _ ->
      dict.insert(
        headers,
        "Content-Length",
        int.to_string(bit_array.byte_size(body)),
      )
  }
  let headers = rest.set_default_header(headers, "Accept", "application/json")
  let path = rest.build_path(path, query)
  #("PATCH", path, headers, body)
}

pub fn parse_update_vpc_link_response(
  _code: Int,
  _headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(VpcLink, String) {
  case bit_array.to_string(body) {
    Ok(text) ->
      case text {
        "" -> decode_update_vpc_link_output("{}")
        _ -> decode_update_vpc_link_output(text)
      }
    Error(_) -> Error("non-utf8 body")
  }
}

pub type CreateApiKeyError {
  CreateApiKeyErrorBadRequestException(value: BadRequestException)
  CreateApiKeyErrorConflictException(value: ConflictException)
  CreateApiKeyErrorLimitExceededException(value: LimitExceededException)
  CreateApiKeyErrorNotFoundException(value: NotFoundException)
  CreateApiKeyErrorTooManyRequestsException(value: TooManyRequestsException)
  CreateApiKeyErrorUnauthorizedException(value: UnauthorizedException)
  CreateApiKeyErrorTransport(reason: String)
  CreateApiKeyErrorUnknown(error_type: String, status: Int, body: String)
}

fn create_api_key_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(CreateApiKeyErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(CreateApiKeyErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(CreateApiKeyErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(CreateApiKeyErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(CreateApiKeyErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(CreateApiKeyErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_create_api_key_error(
  err: runtime.ClientError,
) -> CreateApiKeyError {
  runtime.translate_service_error(
    err,
    create_api_key_error_decoders(),
    fn(reason) { CreateApiKeyErrorTransport(reason: reason) },
    fn(et, s, body) {
      CreateApiKeyErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type CreateAuthorizerError {
  CreateAuthorizerErrorBadRequestException(value: BadRequestException)
  CreateAuthorizerErrorConflictException(value: ConflictException)
  CreateAuthorizerErrorLimitExceededException(value: LimitExceededException)
  CreateAuthorizerErrorNotFoundException(value: NotFoundException)
  CreateAuthorizerErrorTooManyRequestsException(value: TooManyRequestsException)
  CreateAuthorizerErrorUnauthorizedException(value: UnauthorizedException)
  CreateAuthorizerErrorTransport(reason: String)
  CreateAuthorizerErrorUnknown(error_type: String, status: Int, body: String)
}

fn create_authorizer_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(CreateAuthorizerErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(CreateAuthorizerErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(CreateAuthorizerErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(CreateAuthorizerErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(CreateAuthorizerErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(CreateAuthorizerErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_create_authorizer_error(
  err: runtime.ClientError,
) -> CreateAuthorizerError {
  runtime.translate_service_error(
    err,
    create_authorizer_error_decoders(),
    fn(reason) { CreateAuthorizerErrorTransport(reason: reason) },
    fn(et, s, body) {
      CreateAuthorizerErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type CreateBasePathMappingError {
  CreateBasePathMappingErrorBadRequestException(value: BadRequestException)
  CreateBasePathMappingErrorConflictException(value: ConflictException)
  CreateBasePathMappingErrorLimitExceededException(
    value: LimitExceededException,
  )
  CreateBasePathMappingErrorNotFoundException(value: NotFoundException)
  CreateBasePathMappingErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  CreateBasePathMappingErrorUnauthorizedException(value: UnauthorizedException)
  CreateBasePathMappingErrorTransport(reason: String)
  CreateBasePathMappingErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn create_base_path_mapping_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(CreateBasePathMappingErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(CreateBasePathMappingErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(CreateBasePathMappingErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(CreateBasePathMappingErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) ->
          Ok(CreateBasePathMappingErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(CreateBasePathMappingErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_create_base_path_mapping_error(
  err: runtime.ClientError,
) -> CreateBasePathMappingError {
  runtime.translate_service_error(
    err,
    create_base_path_mapping_error_decoders(),
    fn(reason) { CreateBasePathMappingErrorTransport(reason: reason) },
    fn(et, s, body) {
      CreateBasePathMappingErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type CreateDeploymentError {
  CreateDeploymentErrorBadRequestException(value: BadRequestException)
  CreateDeploymentErrorConflictException(value: ConflictException)
  CreateDeploymentErrorLimitExceededException(value: LimitExceededException)
  CreateDeploymentErrorNotFoundException(value: NotFoundException)
  CreateDeploymentErrorServiceUnavailableException(
    value: ServiceUnavailableException,
  )
  CreateDeploymentErrorTooManyRequestsException(value: TooManyRequestsException)
  CreateDeploymentErrorUnauthorizedException(value: UnauthorizedException)
  CreateDeploymentErrorTransport(reason: String)
  CreateDeploymentErrorUnknown(error_type: String, status: Int, body: String)
}

fn create_deployment_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(CreateDeploymentErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(CreateDeploymentErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(CreateDeploymentErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(CreateDeploymentErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ServiceUnavailableException", fn(body) {
      case json.parse(body, decode_service_unavailable_exception_struct()) {
        Ok(v) -> Ok(CreateDeploymentErrorServiceUnavailableException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(CreateDeploymentErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(CreateDeploymentErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_create_deployment_error(
  err: runtime.ClientError,
) -> CreateDeploymentError {
  runtime.translate_service_error(
    err,
    create_deployment_error_decoders(),
    fn(reason) { CreateDeploymentErrorTransport(reason: reason) },
    fn(et, s, body) {
      CreateDeploymentErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type CreateDocumentationPartError {
  CreateDocumentationPartErrorBadRequestException(value: BadRequestException)
  CreateDocumentationPartErrorConflictException(value: ConflictException)
  CreateDocumentationPartErrorLimitExceededException(
    value: LimitExceededException,
  )
  CreateDocumentationPartErrorNotFoundException(value: NotFoundException)
  CreateDocumentationPartErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  CreateDocumentationPartErrorUnauthorizedException(
    value: UnauthorizedException,
  )
  CreateDocumentationPartErrorTransport(reason: String)
  CreateDocumentationPartErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn create_documentation_part_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(CreateDocumentationPartErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(CreateDocumentationPartErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) ->
          Ok(CreateDocumentationPartErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(CreateDocumentationPartErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) ->
          Ok(CreateDocumentationPartErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(CreateDocumentationPartErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_create_documentation_part_error(
  err: runtime.ClientError,
) -> CreateDocumentationPartError {
  runtime.translate_service_error(
    err,
    create_documentation_part_error_decoders(),
    fn(reason) { CreateDocumentationPartErrorTransport(reason: reason) },
    fn(et, s, body) {
      CreateDocumentationPartErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type CreateDocumentationVersionError {
  CreateDocumentationVersionErrorBadRequestException(value: BadRequestException)
  CreateDocumentationVersionErrorConflictException(value: ConflictException)
  CreateDocumentationVersionErrorLimitExceededException(
    value: LimitExceededException,
  )
  CreateDocumentationVersionErrorNotFoundException(value: NotFoundException)
  CreateDocumentationVersionErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  CreateDocumentationVersionErrorUnauthorizedException(
    value: UnauthorizedException,
  )
  CreateDocumentationVersionErrorTransport(reason: String)
  CreateDocumentationVersionErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn create_documentation_version_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) ->
          Ok(CreateDocumentationVersionErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(CreateDocumentationVersionErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) ->
          Ok(CreateDocumentationVersionErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(CreateDocumentationVersionErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) ->
          Ok(CreateDocumentationVersionErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) ->
          Ok(CreateDocumentationVersionErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_create_documentation_version_error(
  err: runtime.ClientError,
) -> CreateDocumentationVersionError {
  runtime.translate_service_error(
    err,
    create_documentation_version_error_decoders(),
    fn(reason) { CreateDocumentationVersionErrorTransport(reason: reason) },
    fn(et, s, body) {
      CreateDocumentationVersionErrorUnknown(
        error_type: et,
        status: s,
        body: body,
      )
    },
  )
}

pub type CreateDomainNameError {
  CreateDomainNameErrorBadRequestException(value: BadRequestException)
  CreateDomainNameErrorConflictException(value: ConflictException)
  CreateDomainNameErrorLimitExceededException(value: LimitExceededException)
  CreateDomainNameErrorTooManyRequestsException(value: TooManyRequestsException)
  CreateDomainNameErrorUnauthorizedException(value: UnauthorizedException)
  CreateDomainNameErrorTransport(reason: String)
  CreateDomainNameErrorUnknown(error_type: String, status: Int, body: String)
}

fn create_domain_name_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(CreateDomainNameErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(CreateDomainNameErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(CreateDomainNameErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(CreateDomainNameErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(CreateDomainNameErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_create_domain_name_error(
  err: runtime.ClientError,
) -> CreateDomainNameError {
  runtime.translate_service_error(
    err,
    create_domain_name_error_decoders(),
    fn(reason) { CreateDomainNameErrorTransport(reason: reason) },
    fn(et, s, body) {
      CreateDomainNameErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type CreateDomainNameAccessAssociationError {
  CreateDomainNameAccessAssociationErrorBadRequestException(
    value: BadRequestException,
  )
  CreateDomainNameAccessAssociationErrorConflictException(
    value: ConflictException,
  )
  CreateDomainNameAccessAssociationErrorLimitExceededException(
    value: LimitExceededException,
  )
  CreateDomainNameAccessAssociationErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  CreateDomainNameAccessAssociationErrorUnauthorizedException(
    value: UnauthorizedException,
  )
  CreateDomainNameAccessAssociationErrorTransport(reason: String)
  CreateDomainNameAccessAssociationErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn create_domain_name_access_association_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) ->
          Ok(CreateDomainNameAccessAssociationErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) ->
          Ok(CreateDomainNameAccessAssociationErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) ->
          Ok(CreateDomainNameAccessAssociationErrorLimitExceededException(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) ->
          Ok(CreateDomainNameAccessAssociationErrorTooManyRequestsException(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) ->
          Ok(CreateDomainNameAccessAssociationErrorUnauthorizedException(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_create_domain_name_access_association_error(
  err: runtime.ClientError,
) -> CreateDomainNameAccessAssociationError {
  runtime.translate_service_error(
    err,
    create_domain_name_access_association_error_decoders(),
    fn(reason) {
      CreateDomainNameAccessAssociationErrorTransport(reason: reason)
    },
    fn(et, s, body) {
      CreateDomainNameAccessAssociationErrorUnknown(
        error_type: et,
        status: s,
        body: body,
      )
    },
  )
}

pub type CreateModelError {
  CreateModelErrorBadRequestException(value: BadRequestException)
  CreateModelErrorConflictException(value: ConflictException)
  CreateModelErrorLimitExceededException(value: LimitExceededException)
  CreateModelErrorNotFoundException(value: NotFoundException)
  CreateModelErrorTooManyRequestsException(value: TooManyRequestsException)
  CreateModelErrorUnauthorizedException(value: UnauthorizedException)
  CreateModelErrorTransport(reason: String)
  CreateModelErrorUnknown(error_type: String, status: Int, body: String)
}

fn create_model_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(CreateModelErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(CreateModelErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(CreateModelErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(CreateModelErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(CreateModelErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(CreateModelErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_create_model_error(err: runtime.ClientError) -> CreateModelError {
  runtime.translate_service_error(
    err,
    create_model_error_decoders(),
    fn(reason) { CreateModelErrorTransport(reason: reason) },
    fn(et, s, body) {
      CreateModelErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type CreateRequestValidatorError {
  CreateRequestValidatorErrorBadRequestException(value: BadRequestException)
  CreateRequestValidatorErrorConflictException(value: ConflictException)
  CreateRequestValidatorErrorLimitExceededException(
    value: LimitExceededException,
  )
  CreateRequestValidatorErrorNotFoundException(value: NotFoundException)
  CreateRequestValidatorErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  CreateRequestValidatorErrorUnauthorizedException(value: UnauthorizedException)
  CreateRequestValidatorErrorTransport(reason: String)
  CreateRequestValidatorErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn create_request_validator_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(CreateRequestValidatorErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(CreateRequestValidatorErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(CreateRequestValidatorErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(CreateRequestValidatorErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) ->
          Ok(CreateRequestValidatorErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(CreateRequestValidatorErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_create_request_validator_error(
  err: runtime.ClientError,
) -> CreateRequestValidatorError {
  runtime.translate_service_error(
    err,
    create_request_validator_error_decoders(),
    fn(reason) { CreateRequestValidatorErrorTransport(reason: reason) },
    fn(et, s, body) {
      CreateRequestValidatorErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type CreateResourceError {
  CreateResourceErrorBadRequestException(value: BadRequestException)
  CreateResourceErrorConflictException(value: ConflictException)
  CreateResourceErrorLimitExceededException(value: LimitExceededException)
  CreateResourceErrorNotFoundException(value: NotFoundException)
  CreateResourceErrorTooManyRequestsException(value: TooManyRequestsException)
  CreateResourceErrorUnauthorizedException(value: UnauthorizedException)
  CreateResourceErrorTransport(reason: String)
  CreateResourceErrorUnknown(error_type: String, status: Int, body: String)
}

fn create_resource_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(CreateResourceErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(CreateResourceErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(CreateResourceErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(CreateResourceErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(CreateResourceErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(CreateResourceErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_create_resource_error(
  err: runtime.ClientError,
) -> CreateResourceError {
  runtime.translate_service_error(
    err,
    create_resource_error_decoders(),
    fn(reason) { CreateResourceErrorTransport(reason: reason) },
    fn(et, s, body) {
      CreateResourceErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type CreateRestApiError {
  CreateRestApiErrorBadRequestException(value: BadRequestException)
  CreateRestApiErrorConflictException(value: ConflictException)
  CreateRestApiErrorLimitExceededException(value: LimitExceededException)
  CreateRestApiErrorTooManyRequestsException(value: TooManyRequestsException)
  CreateRestApiErrorUnauthorizedException(value: UnauthorizedException)
  CreateRestApiErrorTransport(reason: String)
  CreateRestApiErrorUnknown(error_type: String, status: Int, body: String)
}

fn create_rest_api_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(CreateRestApiErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(CreateRestApiErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(CreateRestApiErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(CreateRestApiErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(CreateRestApiErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_create_rest_api_error(
  err: runtime.ClientError,
) -> CreateRestApiError {
  runtime.translate_service_error(
    err,
    create_rest_api_error_decoders(),
    fn(reason) { CreateRestApiErrorTransport(reason: reason) },
    fn(et, s, body) {
      CreateRestApiErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type CreateStageError {
  CreateStageErrorBadRequestException(value: BadRequestException)
  CreateStageErrorConflictException(value: ConflictException)
  CreateStageErrorLimitExceededException(value: LimitExceededException)
  CreateStageErrorNotFoundException(value: NotFoundException)
  CreateStageErrorTooManyRequestsException(value: TooManyRequestsException)
  CreateStageErrorUnauthorizedException(value: UnauthorizedException)
  CreateStageErrorTransport(reason: String)
  CreateStageErrorUnknown(error_type: String, status: Int, body: String)
}

fn create_stage_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(CreateStageErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(CreateStageErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(CreateStageErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(CreateStageErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(CreateStageErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(CreateStageErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_create_stage_error(err: runtime.ClientError) -> CreateStageError {
  runtime.translate_service_error(
    err,
    create_stage_error_decoders(),
    fn(reason) { CreateStageErrorTransport(reason: reason) },
    fn(et, s, body) {
      CreateStageErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type CreateUsagePlanError {
  CreateUsagePlanErrorBadRequestException(value: BadRequestException)
  CreateUsagePlanErrorConflictException(value: ConflictException)
  CreateUsagePlanErrorLimitExceededException(value: LimitExceededException)
  CreateUsagePlanErrorNotFoundException(value: NotFoundException)
  CreateUsagePlanErrorTooManyRequestsException(value: TooManyRequestsException)
  CreateUsagePlanErrorUnauthorizedException(value: UnauthorizedException)
  CreateUsagePlanErrorTransport(reason: String)
  CreateUsagePlanErrorUnknown(error_type: String, status: Int, body: String)
}

fn create_usage_plan_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(CreateUsagePlanErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(CreateUsagePlanErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(CreateUsagePlanErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(CreateUsagePlanErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(CreateUsagePlanErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(CreateUsagePlanErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_create_usage_plan_error(
  err: runtime.ClientError,
) -> CreateUsagePlanError {
  runtime.translate_service_error(
    err,
    create_usage_plan_error_decoders(),
    fn(reason) { CreateUsagePlanErrorTransport(reason: reason) },
    fn(et, s, body) {
      CreateUsagePlanErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type CreateUsagePlanKeyError {
  CreateUsagePlanKeyErrorBadRequestException(value: BadRequestException)
  CreateUsagePlanKeyErrorConflictException(value: ConflictException)
  CreateUsagePlanKeyErrorLimitExceededException(value: LimitExceededException)
  CreateUsagePlanKeyErrorNotFoundException(value: NotFoundException)
  CreateUsagePlanKeyErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  CreateUsagePlanKeyErrorUnauthorizedException(value: UnauthorizedException)
  CreateUsagePlanKeyErrorTransport(reason: String)
  CreateUsagePlanKeyErrorUnknown(error_type: String, status: Int, body: String)
}

fn create_usage_plan_key_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(CreateUsagePlanKeyErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(CreateUsagePlanKeyErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(CreateUsagePlanKeyErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(CreateUsagePlanKeyErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(CreateUsagePlanKeyErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(CreateUsagePlanKeyErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_create_usage_plan_key_error(
  err: runtime.ClientError,
) -> CreateUsagePlanKeyError {
  runtime.translate_service_error(
    err,
    create_usage_plan_key_error_decoders(),
    fn(reason) { CreateUsagePlanKeyErrorTransport(reason: reason) },
    fn(et, s, body) {
      CreateUsagePlanKeyErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type CreateVpcLinkError {
  CreateVpcLinkErrorBadRequestException(value: BadRequestException)
  CreateVpcLinkErrorConflictException(value: ConflictException)
  CreateVpcLinkErrorLimitExceededException(value: LimitExceededException)
  CreateVpcLinkErrorTooManyRequestsException(value: TooManyRequestsException)
  CreateVpcLinkErrorUnauthorizedException(value: UnauthorizedException)
  CreateVpcLinkErrorTransport(reason: String)
  CreateVpcLinkErrorUnknown(error_type: String, status: Int, body: String)
}

fn create_vpc_link_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(CreateVpcLinkErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(CreateVpcLinkErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(CreateVpcLinkErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(CreateVpcLinkErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(CreateVpcLinkErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_create_vpc_link_error(
  err: runtime.ClientError,
) -> CreateVpcLinkError {
  runtime.translate_service_error(
    err,
    create_vpc_link_error_decoders(),
    fn(reason) { CreateVpcLinkErrorTransport(reason: reason) },
    fn(et, s, body) {
      CreateVpcLinkErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type DeleteApiKeyError {
  DeleteApiKeyErrorBadRequestException(value: BadRequestException)
  DeleteApiKeyErrorConflictException(value: ConflictException)
  DeleteApiKeyErrorNotFoundException(value: NotFoundException)
  DeleteApiKeyErrorTooManyRequestsException(value: TooManyRequestsException)
  DeleteApiKeyErrorUnauthorizedException(value: UnauthorizedException)
  DeleteApiKeyErrorTransport(reason: String)
  DeleteApiKeyErrorUnknown(error_type: String, status: Int, body: String)
}

fn delete_api_key_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(DeleteApiKeyErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(DeleteApiKeyErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(DeleteApiKeyErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(DeleteApiKeyErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(DeleteApiKeyErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_delete_api_key_error(
  err: runtime.ClientError,
) -> DeleteApiKeyError {
  runtime.translate_service_error(
    err,
    delete_api_key_error_decoders(),
    fn(reason) { DeleteApiKeyErrorTransport(reason: reason) },
    fn(et, s, body) {
      DeleteApiKeyErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type DeleteAuthorizerError {
  DeleteAuthorizerErrorBadRequestException(value: BadRequestException)
  DeleteAuthorizerErrorConflictException(value: ConflictException)
  DeleteAuthorizerErrorNotFoundException(value: NotFoundException)
  DeleteAuthorizerErrorTooManyRequestsException(value: TooManyRequestsException)
  DeleteAuthorizerErrorUnauthorizedException(value: UnauthorizedException)
  DeleteAuthorizerErrorTransport(reason: String)
  DeleteAuthorizerErrorUnknown(error_type: String, status: Int, body: String)
}

fn delete_authorizer_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(DeleteAuthorizerErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(DeleteAuthorizerErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(DeleteAuthorizerErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(DeleteAuthorizerErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(DeleteAuthorizerErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_delete_authorizer_error(
  err: runtime.ClientError,
) -> DeleteAuthorizerError {
  runtime.translate_service_error(
    err,
    delete_authorizer_error_decoders(),
    fn(reason) { DeleteAuthorizerErrorTransport(reason: reason) },
    fn(et, s, body) {
      DeleteAuthorizerErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type DeleteBasePathMappingError {
  DeleteBasePathMappingErrorBadRequestException(value: BadRequestException)
  DeleteBasePathMappingErrorConflictException(value: ConflictException)
  DeleteBasePathMappingErrorNotFoundException(value: NotFoundException)
  DeleteBasePathMappingErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  DeleteBasePathMappingErrorUnauthorizedException(value: UnauthorizedException)
  DeleteBasePathMappingErrorTransport(reason: String)
  DeleteBasePathMappingErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn delete_base_path_mapping_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(DeleteBasePathMappingErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(DeleteBasePathMappingErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(DeleteBasePathMappingErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) ->
          Ok(DeleteBasePathMappingErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(DeleteBasePathMappingErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_delete_base_path_mapping_error(
  err: runtime.ClientError,
) -> DeleteBasePathMappingError {
  runtime.translate_service_error(
    err,
    delete_base_path_mapping_error_decoders(),
    fn(reason) { DeleteBasePathMappingErrorTransport(reason: reason) },
    fn(et, s, body) {
      DeleteBasePathMappingErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type DeleteClientCertificateError {
  DeleteClientCertificateErrorBadRequestException(value: BadRequestException)
  DeleteClientCertificateErrorConflictException(value: ConflictException)
  DeleteClientCertificateErrorNotFoundException(value: NotFoundException)
  DeleteClientCertificateErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  DeleteClientCertificateErrorUnauthorizedException(
    value: UnauthorizedException,
  )
  DeleteClientCertificateErrorTransport(reason: String)
  DeleteClientCertificateErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn delete_client_certificate_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(DeleteClientCertificateErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(DeleteClientCertificateErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(DeleteClientCertificateErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) ->
          Ok(DeleteClientCertificateErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(DeleteClientCertificateErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_delete_client_certificate_error(
  err: runtime.ClientError,
) -> DeleteClientCertificateError {
  runtime.translate_service_error(
    err,
    delete_client_certificate_error_decoders(),
    fn(reason) { DeleteClientCertificateErrorTransport(reason: reason) },
    fn(et, s, body) {
      DeleteClientCertificateErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type DeleteDeploymentError {
  DeleteDeploymentErrorBadRequestException(value: BadRequestException)
  DeleteDeploymentErrorConflictException(value: ConflictException)
  DeleteDeploymentErrorLimitExceededException(value: LimitExceededException)
  DeleteDeploymentErrorNotFoundException(value: NotFoundException)
  DeleteDeploymentErrorTooManyRequestsException(value: TooManyRequestsException)
  DeleteDeploymentErrorUnauthorizedException(value: UnauthorizedException)
  DeleteDeploymentErrorTransport(reason: String)
  DeleteDeploymentErrorUnknown(error_type: String, status: Int, body: String)
}

fn delete_deployment_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(DeleteDeploymentErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(DeleteDeploymentErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(DeleteDeploymentErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(DeleteDeploymentErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(DeleteDeploymentErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(DeleteDeploymentErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_delete_deployment_error(
  err: runtime.ClientError,
) -> DeleteDeploymentError {
  runtime.translate_service_error(
    err,
    delete_deployment_error_decoders(),
    fn(reason) { DeleteDeploymentErrorTransport(reason: reason) },
    fn(et, s, body) {
      DeleteDeploymentErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type DeleteDocumentationPartError {
  DeleteDocumentationPartErrorBadRequestException(value: BadRequestException)
  DeleteDocumentationPartErrorConflictException(value: ConflictException)
  DeleteDocumentationPartErrorNotFoundException(value: NotFoundException)
  DeleteDocumentationPartErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  DeleteDocumentationPartErrorUnauthorizedException(
    value: UnauthorizedException,
  )
  DeleteDocumentationPartErrorTransport(reason: String)
  DeleteDocumentationPartErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn delete_documentation_part_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(DeleteDocumentationPartErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(DeleteDocumentationPartErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(DeleteDocumentationPartErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) ->
          Ok(DeleteDocumentationPartErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(DeleteDocumentationPartErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_delete_documentation_part_error(
  err: runtime.ClientError,
) -> DeleteDocumentationPartError {
  runtime.translate_service_error(
    err,
    delete_documentation_part_error_decoders(),
    fn(reason) { DeleteDocumentationPartErrorTransport(reason: reason) },
    fn(et, s, body) {
      DeleteDocumentationPartErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type DeleteDocumentationVersionError {
  DeleteDocumentationVersionErrorBadRequestException(value: BadRequestException)
  DeleteDocumentationVersionErrorConflictException(value: ConflictException)
  DeleteDocumentationVersionErrorNotFoundException(value: NotFoundException)
  DeleteDocumentationVersionErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  DeleteDocumentationVersionErrorUnauthorizedException(
    value: UnauthorizedException,
  )
  DeleteDocumentationVersionErrorTransport(reason: String)
  DeleteDocumentationVersionErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn delete_documentation_version_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) ->
          Ok(DeleteDocumentationVersionErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(DeleteDocumentationVersionErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(DeleteDocumentationVersionErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) ->
          Ok(DeleteDocumentationVersionErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) ->
          Ok(DeleteDocumentationVersionErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_delete_documentation_version_error(
  err: runtime.ClientError,
) -> DeleteDocumentationVersionError {
  runtime.translate_service_error(
    err,
    delete_documentation_version_error_decoders(),
    fn(reason) { DeleteDocumentationVersionErrorTransport(reason: reason) },
    fn(et, s, body) {
      DeleteDocumentationVersionErrorUnknown(
        error_type: et,
        status: s,
        body: body,
      )
    },
  )
}

pub type DeleteDomainNameError {
  DeleteDomainNameErrorBadRequestException(value: BadRequestException)
  DeleteDomainNameErrorConflictException(value: ConflictException)
  DeleteDomainNameErrorNotFoundException(value: NotFoundException)
  DeleteDomainNameErrorTooManyRequestsException(value: TooManyRequestsException)
  DeleteDomainNameErrorUnauthorizedException(value: UnauthorizedException)
  DeleteDomainNameErrorTransport(reason: String)
  DeleteDomainNameErrorUnknown(error_type: String, status: Int, body: String)
}

fn delete_domain_name_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(DeleteDomainNameErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(DeleteDomainNameErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(DeleteDomainNameErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(DeleteDomainNameErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(DeleteDomainNameErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_delete_domain_name_error(
  err: runtime.ClientError,
) -> DeleteDomainNameError {
  runtime.translate_service_error(
    err,
    delete_domain_name_error_decoders(),
    fn(reason) { DeleteDomainNameErrorTransport(reason: reason) },
    fn(et, s, body) {
      DeleteDomainNameErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type DeleteDomainNameAccessAssociationError {
  DeleteDomainNameAccessAssociationErrorBadRequestException(
    value: BadRequestException,
  )
  DeleteDomainNameAccessAssociationErrorConflictException(
    value: ConflictException,
  )
  DeleteDomainNameAccessAssociationErrorNotFoundException(
    value: NotFoundException,
  )
  DeleteDomainNameAccessAssociationErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  DeleteDomainNameAccessAssociationErrorUnauthorizedException(
    value: UnauthorizedException,
  )
  DeleteDomainNameAccessAssociationErrorTransport(reason: String)
  DeleteDomainNameAccessAssociationErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn delete_domain_name_access_association_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) ->
          Ok(DeleteDomainNameAccessAssociationErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) ->
          Ok(DeleteDomainNameAccessAssociationErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) ->
          Ok(DeleteDomainNameAccessAssociationErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) ->
          Ok(DeleteDomainNameAccessAssociationErrorTooManyRequestsException(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) ->
          Ok(DeleteDomainNameAccessAssociationErrorUnauthorizedException(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_delete_domain_name_access_association_error(
  err: runtime.ClientError,
) -> DeleteDomainNameAccessAssociationError {
  runtime.translate_service_error(
    err,
    delete_domain_name_access_association_error_decoders(),
    fn(reason) {
      DeleteDomainNameAccessAssociationErrorTransport(reason: reason)
    },
    fn(et, s, body) {
      DeleteDomainNameAccessAssociationErrorUnknown(
        error_type: et,
        status: s,
        body: body,
      )
    },
  )
}

pub type DeleteGatewayResponseError {
  DeleteGatewayResponseErrorBadRequestException(value: BadRequestException)
  DeleteGatewayResponseErrorConflictException(value: ConflictException)
  DeleteGatewayResponseErrorNotFoundException(value: NotFoundException)
  DeleteGatewayResponseErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  DeleteGatewayResponseErrorUnauthorizedException(value: UnauthorizedException)
  DeleteGatewayResponseErrorTransport(reason: String)
  DeleteGatewayResponseErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn delete_gateway_response_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(DeleteGatewayResponseErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(DeleteGatewayResponseErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(DeleteGatewayResponseErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) ->
          Ok(DeleteGatewayResponseErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(DeleteGatewayResponseErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_delete_gateway_response_error(
  err: runtime.ClientError,
) -> DeleteGatewayResponseError {
  runtime.translate_service_error(
    err,
    delete_gateway_response_error_decoders(),
    fn(reason) { DeleteGatewayResponseErrorTransport(reason: reason) },
    fn(et, s, body) {
      DeleteGatewayResponseErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type DeleteIntegrationError {
  DeleteIntegrationErrorBadRequestException(value: BadRequestException)
  DeleteIntegrationErrorConflictException(value: ConflictException)
  DeleteIntegrationErrorNotFoundException(value: NotFoundException)
  DeleteIntegrationErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  DeleteIntegrationErrorUnauthorizedException(value: UnauthorizedException)
  DeleteIntegrationErrorTransport(reason: String)
  DeleteIntegrationErrorUnknown(error_type: String, status: Int, body: String)
}

fn delete_integration_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(DeleteIntegrationErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(DeleteIntegrationErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(DeleteIntegrationErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(DeleteIntegrationErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(DeleteIntegrationErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_delete_integration_error(
  err: runtime.ClientError,
) -> DeleteIntegrationError {
  runtime.translate_service_error(
    err,
    delete_integration_error_decoders(),
    fn(reason) { DeleteIntegrationErrorTransport(reason: reason) },
    fn(et, s, body) {
      DeleteIntegrationErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type DeleteIntegrationResponseError {
  DeleteIntegrationResponseErrorBadRequestException(value: BadRequestException)
  DeleteIntegrationResponseErrorConflictException(value: ConflictException)
  DeleteIntegrationResponseErrorNotFoundException(value: NotFoundException)
  DeleteIntegrationResponseErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  DeleteIntegrationResponseErrorUnauthorizedException(
    value: UnauthorizedException,
  )
  DeleteIntegrationResponseErrorTransport(reason: String)
  DeleteIntegrationResponseErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn delete_integration_response_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(DeleteIntegrationResponseErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(DeleteIntegrationResponseErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(DeleteIntegrationResponseErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) ->
          Ok(DeleteIntegrationResponseErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) ->
          Ok(DeleteIntegrationResponseErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_delete_integration_response_error(
  err: runtime.ClientError,
) -> DeleteIntegrationResponseError {
  runtime.translate_service_error(
    err,
    delete_integration_response_error_decoders(),
    fn(reason) { DeleteIntegrationResponseErrorTransport(reason: reason) },
    fn(et, s, body) {
      DeleteIntegrationResponseErrorUnknown(
        error_type: et,
        status: s,
        body: body,
      )
    },
  )
}

pub type DeleteMethodError {
  DeleteMethodErrorConflictException(value: ConflictException)
  DeleteMethodErrorNotFoundException(value: NotFoundException)
  DeleteMethodErrorTooManyRequestsException(value: TooManyRequestsException)
  DeleteMethodErrorUnauthorizedException(value: UnauthorizedException)
  DeleteMethodErrorTransport(reason: String)
  DeleteMethodErrorUnknown(error_type: String, status: Int, body: String)
}

fn delete_method_error_decoders() {
  [
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(DeleteMethodErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(DeleteMethodErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(DeleteMethodErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(DeleteMethodErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_delete_method_error(
  err: runtime.ClientError,
) -> DeleteMethodError {
  runtime.translate_service_error(
    err,
    delete_method_error_decoders(),
    fn(reason) { DeleteMethodErrorTransport(reason: reason) },
    fn(et, s, body) {
      DeleteMethodErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type DeleteMethodResponseError {
  DeleteMethodResponseErrorBadRequestException(value: BadRequestException)
  DeleteMethodResponseErrorConflictException(value: ConflictException)
  DeleteMethodResponseErrorNotFoundException(value: NotFoundException)
  DeleteMethodResponseErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  DeleteMethodResponseErrorUnauthorizedException(value: UnauthorizedException)
  DeleteMethodResponseErrorTransport(reason: String)
  DeleteMethodResponseErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn delete_method_response_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(DeleteMethodResponseErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(DeleteMethodResponseErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(DeleteMethodResponseErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(DeleteMethodResponseErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(DeleteMethodResponseErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_delete_method_response_error(
  err: runtime.ClientError,
) -> DeleteMethodResponseError {
  runtime.translate_service_error(
    err,
    delete_method_response_error_decoders(),
    fn(reason) { DeleteMethodResponseErrorTransport(reason: reason) },
    fn(et, s, body) {
      DeleteMethodResponseErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type DeleteModelError {
  DeleteModelErrorBadRequestException(value: BadRequestException)
  DeleteModelErrorConflictException(value: ConflictException)
  DeleteModelErrorNotFoundException(value: NotFoundException)
  DeleteModelErrorTooManyRequestsException(value: TooManyRequestsException)
  DeleteModelErrorUnauthorizedException(value: UnauthorizedException)
  DeleteModelErrorTransport(reason: String)
  DeleteModelErrorUnknown(error_type: String, status: Int, body: String)
}

fn delete_model_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(DeleteModelErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(DeleteModelErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(DeleteModelErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(DeleteModelErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(DeleteModelErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_delete_model_error(err: runtime.ClientError) -> DeleteModelError {
  runtime.translate_service_error(
    err,
    delete_model_error_decoders(),
    fn(reason) { DeleteModelErrorTransport(reason: reason) },
    fn(et, s, body) {
      DeleteModelErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type DeleteRequestValidatorError {
  DeleteRequestValidatorErrorBadRequestException(value: BadRequestException)
  DeleteRequestValidatorErrorConflictException(value: ConflictException)
  DeleteRequestValidatorErrorNotFoundException(value: NotFoundException)
  DeleteRequestValidatorErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  DeleteRequestValidatorErrorUnauthorizedException(value: UnauthorizedException)
  DeleteRequestValidatorErrorTransport(reason: String)
  DeleteRequestValidatorErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn delete_request_validator_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(DeleteRequestValidatorErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(DeleteRequestValidatorErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(DeleteRequestValidatorErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) ->
          Ok(DeleteRequestValidatorErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(DeleteRequestValidatorErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_delete_request_validator_error(
  err: runtime.ClientError,
) -> DeleteRequestValidatorError {
  runtime.translate_service_error(
    err,
    delete_request_validator_error_decoders(),
    fn(reason) { DeleteRequestValidatorErrorTransport(reason: reason) },
    fn(et, s, body) {
      DeleteRequestValidatorErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type DeleteResourceError {
  DeleteResourceErrorBadRequestException(value: BadRequestException)
  DeleteResourceErrorConflictException(value: ConflictException)
  DeleteResourceErrorNotFoundException(value: NotFoundException)
  DeleteResourceErrorTooManyRequestsException(value: TooManyRequestsException)
  DeleteResourceErrorUnauthorizedException(value: UnauthorizedException)
  DeleteResourceErrorTransport(reason: String)
  DeleteResourceErrorUnknown(error_type: String, status: Int, body: String)
}

fn delete_resource_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(DeleteResourceErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(DeleteResourceErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(DeleteResourceErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(DeleteResourceErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(DeleteResourceErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_delete_resource_error(
  err: runtime.ClientError,
) -> DeleteResourceError {
  runtime.translate_service_error(
    err,
    delete_resource_error_decoders(),
    fn(reason) { DeleteResourceErrorTransport(reason: reason) },
    fn(et, s, body) {
      DeleteResourceErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type DeleteRestApiError {
  DeleteRestApiErrorBadRequestException(value: BadRequestException)
  DeleteRestApiErrorConflictException(value: ConflictException)
  DeleteRestApiErrorNotFoundException(value: NotFoundException)
  DeleteRestApiErrorTooManyRequestsException(value: TooManyRequestsException)
  DeleteRestApiErrorUnauthorizedException(value: UnauthorizedException)
  DeleteRestApiErrorTransport(reason: String)
  DeleteRestApiErrorUnknown(error_type: String, status: Int, body: String)
}

fn delete_rest_api_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(DeleteRestApiErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(DeleteRestApiErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(DeleteRestApiErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(DeleteRestApiErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(DeleteRestApiErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_delete_rest_api_error(
  err: runtime.ClientError,
) -> DeleteRestApiError {
  runtime.translate_service_error(
    err,
    delete_rest_api_error_decoders(),
    fn(reason) { DeleteRestApiErrorTransport(reason: reason) },
    fn(et, s, body) {
      DeleteRestApiErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type DeleteStageError {
  DeleteStageErrorBadRequestException(value: BadRequestException)
  DeleteStageErrorConflictException(value: ConflictException)
  DeleteStageErrorLimitExceededException(value: LimitExceededException)
  DeleteStageErrorNotFoundException(value: NotFoundException)
  DeleteStageErrorTooManyRequestsException(value: TooManyRequestsException)
  DeleteStageErrorUnauthorizedException(value: UnauthorizedException)
  DeleteStageErrorTransport(reason: String)
  DeleteStageErrorUnknown(error_type: String, status: Int, body: String)
}

fn delete_stage_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(DeleteStageErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(DeleteStageErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(DeleteStageErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(DeleteStageErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(DeleteStageErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(DeleteStageErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_delete_stage_error(err: runtime.ClientError) -> DeleteStageError {
  runtime.translate_service_error(
    err,
    delete_stage_error_decoders(),
    fn(reason) { DeleteStageErrorTransport(reason: reason) },
    fn(et, s, body) {
      DeleteStageErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type DeleteUsagePlanError {
  DeleteUsagePlanErrorBadRequestException(value: BadRequestException)
  DeleteUsagePlanErrorConflictException(value: ConflictException)
  DeleteUsagePlanErrorNotFoundException(value: NotFoundException)
  DeleteUsagePlanErrorTooManyRequestsException(value: TooManyRequestsException)
  DeleteUsagePlanErrorUnauthorizedException(value: UnauthorizedException)
  DeleteUsagePlanErrorTransport(reason: String)
  DeleteUsagePlanErrorUnknown(error_type: String, status: Int, body: String)
}

fn delete_usage_plan_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(DeleteUsagePlanErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(DeleteUsagePlanErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(DeleteUsagePlanErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(DeleteUsagePlanErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(DeleteUsagePlanErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_delete_usage_plan_error(
  err: runtime.ClientError,
) -> DeleteUsagePlanError {
  runtime.translate_service_error(
    err,
    delete_usage_plan_error_decoders(),
    fn(reason) { DeleteUsagePlanErrorTransport(reason: reason) },
    fn(et, s, body) {
      DeleteUsagePlanErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type DeleteUsagePlanKeyError {
  DeleteUsagePlanKeyErrorBadRequestException(value: BadRequestException)
  DeleteUsagePlanKeyErrorConflictException(value: ConflictException)
  DeleteUsagePlanKeyErrorNotFoundException(value: NotFoundException)
  DeleteUsagePlanKeyErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  DeleteUsagePlanKeyErrorUnauthorizedException(value: UnauthorizedException)
  DeleteUsagePlanKeyErrorTransport(reason: String)
  DeleteUsagePlanKeyErrorUnknown(error_type: String, status: Int, body: String)
}

fn delete_usage_plan_key_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(DeleteUsagePlanKeyErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(DeleteUsagePlanKeyErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(DeleteUsagePlanKeyErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(DeleteUsagePlanKeyErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(DeleteUsagePlanKeyErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_delete_usage_plan_key_error(
  err: runtime.ClientError,
) -> DeleteUsagePlanKeyError {
  runtime.translate_service_error(
    err,
    delete_usage_plan_key_error_decoders(),
    fn(reason) { DeleteUsagePlanKeyErrorTransport(reason: reason) },
    fn(et, s, body) {
      DeleteUsagePlanKeyErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type DeleteVpcLinkError {
  DeleteVpcLinkErrorBadRequestException(value: BadRequestException)
  DeleteVpcLinkErrorConflictException(value: ConflictException)
  DeleteVpcLinkErrorNotFoundException(value: NotFoundException)
  DeleteVpcLinkErrorTooManyRequestsException(value: TooManyRequestsException)
  DeleteVpcLinkErrorUnauthorizedException(value: UnauthorizedException)
  DeleteVpcLinkErrorTransport(reason: String)
  DeleteVpcLinkErrorUnknown(error_type: String, status: Int, body: String)
}

fn delete_vpc_link_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(DeleteVpcLinkErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(DeleteVpcLinkErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(DeleteVpcLinkErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(DeleteVpcLinkErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(DeleteVpcLinkErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_delete_vpc_link_error(
  err: runtime.ClientError,
) -> DeleteVpcLinkError {
  runtime.translate_service_error(
    err,
    delete_vpc_link_error_decoders(),
    fn(reason) { DeleteVpcLinkErrorTransport(reason: reason) },
    fn(et, s, body) {
      DeleteVpcLinkErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type FlushStageAuthorizersCacheError {
  FlushStageAuthorizersCacheErrorBadRequestException(value: BadRequestException)
  FlushStageAuthorizersCacheErrorConflictException(value: ConflictException)
  FlushStageAuthorizersCacheErrorLimitExceededException(
    value: LimitExceededException,
  )
  FlushStageAuthorizersCacheErrorNotFoundException(value: NotFoundException)
  FlushStageAuthorizersCacheErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  FlushStageAuthorizersCacheErrorUnauthorizedException(
    value: UnauthorizedException,
  )
  FlushStageAuthorizersCacheErrorTransport(reason: String)
  FlushStageAuthorizersCacheErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn flush_stage_authorizers_cache_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) ->
          Ok(FlushStageAuthorizersCacheErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(FlushStageAuthorizersCacheErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) ->
          Ok(FlushStageAuthorizersCacheErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(FlushStageAuthorizersCacheErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) ->
          Ok(FlushStageAuthorizersCacheErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) ->
          Ok(FlushStageAuthorizersCacheErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_flush_stage_authorizers_cache_error(
  err: runtime.ClientError,
) -> FlushStageAuthorizersCacheError {
  runtime.translate_service_error(
    err,
    flush_stage_authorizers_cache_error_decoders(),
    fn(reason) { FlushStageAuthorizersCacheErrorTransport(reason: reason) },
    fn(et, s, body) {
      FlushStageAuthorizersCacheErrorUnknown(
        error_type: et,
        status: s,
        body: body,
      )
    },
  )
}

pub type FlushStageCacheError {
  FlushStageCacheErrorBadRequestException(value: BadRequestException)
  FlushStageCacheErrorConflictException(value: ConflictException)
  FlushStageCacheErrorLimitExceededException(value: LimitExceededException)
  FlushStageCacheErrorNotFoundException(value: NotFoundException)
  FlushStageCacheErrorTooManyRequestsException(value: TooManyRequestsException)
  FlushStageCacheErrorUnauthorizedException(value: UnauthorizedException)
  FlushStageCacheErrorTransport(reason: String)
  FlushStageCacheErrorUnknown(error_type: String, status: Int, body: String)
}

fn flush_stage_cache_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(FlushStageCacheErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(FlushStageCacheErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(FlushStageCacheErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(FlushStageCacheErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(FlushStageCacheErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(FlushStageCacheErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_flush_stage_cache_error(
  err: runtime.ClientError,
) -> FlushStageCacheError {
  runtime.translate_service_error(
    err,
    flush_stage_cache_error_decoders(),
    fn(reason) { FlushStageCacheErrorTransport(reason: reason) },
    fn(et, s, body) {
      FlushStageCacheErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GenerateClientCertificateError {
  GenerateClientCertificateErrorBadRequestException(value: BadRequestException)
  GenerateClientCertificateErrorConflictException(value: ConflictException)
  GenerateClientCertificateErrorLimitExceededException(
    value: LimitExceededException,
  )
  GenerateClientCertificateErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  GenerateClientCertificateErrorUnauthorizedException(
    value: UnauthorizedException,
  )
  GenerateClientCertificateErrorTransport(reason: String)
  GenerateClientCertificateErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn generate_client_certificate_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GenerateClientCertificateErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(GenerateClientCertificateErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) ->
          Ok(GenerateClientCertificateErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) ->
          Ok(GenerateClientCertificateErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) ->
          Ok(GenerateClientCertificateErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_generate_client_certificate_error(
  err: runtime.ClientError,
) -> GenerateClientCertificateError {
  runtime.translate_service_error(
    err,
    generate_client_certificate_error_decoders(),
    fn(reason) { GenerateClientCertificateErrorTransport(reason: reason) },
    fn(et, s, body) {
      GenerateClientCertificateErrorUnknown(
        error_type: et,
        status: s,
        body: body,
      )
    },
  )
}

pub type GetAccountError {
  GetAccountErrorBadRequestException(value: BadRequestException)
  GetAccountErrorNotFoundException(value: NotFoundException)
  GetAccountErrorTooManyRequestsException(value: TooManyRequestsException)
  GetAccountErrorUnauthorizedException(value: UnauthorizedException)
  GetAccountErrorTransport(reason: String)
  GetAccountErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_account_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetAccountErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetAccountErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetAccountErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetAccountErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_account_error(err: runtime.ClientError) -> GetAccountError {
  runtime.translate_service_error(
    err,
    get_account_error_decoders(),
    fn(reason) { GetAccountErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetAccountErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetApiKeyError {
  GetApiKeyErrorBadRequestException(value: BadRequestException)
  GetApiKeyErrorNotFoundException(value: NotFoundException)
  GetApiKeyErrorTooManyRequestsException(value: TooManyRequestsException)
  GetApiKeyErrorUnauthorizedException(value: UnauthorizedException)
  GetApiKeyErrorTransport(reason: String)
  GetApiKeyErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_api_key_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetApiKeyErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetApiKeyErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetApiKeyErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetApiKeyErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_api_key_error(err: runtime.ClientError) -> GetApiKeyError {
  runtime.translate_service_error(
    err,
    get_api_key_error_decoders(),
    fn(reason) { GetApiKeyErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetApiKeyErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetApiKeysError {
  GetApiKeysErrorBadRequestException(value: BadRequestException)
  GetApiKeysErrorNotFoundException(value: NotFoundException)
  GetApiKeysErrorTooManyRequestsException(value: TooManyRequestsException)
  GetApiKeysErrorUnauthorizedException(value: UnauthorizedException)
  GetApiKeysErrorTransport(reason: String)
  GetApiKeysErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_api_keys_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetApiKeysErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetApiKeysErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetApiKeysErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetApiKeysErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_api_keys_error(err: runtime.ClientError) -> GetApiKeysError {
  runtime.translate_service_error(
    err,
    get_api_keys_error_decoders(),
    fn(reason) { GetApiKeysErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetApiKeysErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetAuthorizerError {
  GetAuthorizerErrorBadRequestException(value: BadRequestException)
  GetAuthorizerErrorNotFoundException(value: NotFoundException)
  GetAuthorizerErrorTooManyRequestsException(value: TooManyRequestsException)
  GetAuthorizerErrorUnauthorizedException(value: UnauthorizedException)
  GetAuthorizerErrorTransport(reason: String)
  GetAuthorizerErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_authorizer_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetAuthorizerErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetAuthorizerErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetAuthorizerErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetAuthorizerErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_authorizer_error(
  err: runtime.ClientError,
) -> GetAuthorizerError {
  runtime.translate_service_error(
    err,
    get_authorizer_error_decoders(),
    fn(reason) { GetAuthorizerErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetAuthorizerErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetAuthorizersError {
  GetAuthorizersErrorBadRequestException(value: BadRequestException)
  GetAuthorizersErrorNotFoundException(value: NotFoundException)
  GetAuthorizersErrorTooManyRequestsException(value: TooManyRequestsException)
  GetAuthorizersErrorUnauthorizedException(value: UnauthorizedException)
  GetAuthorizersErrorTransport(reason: String)
  GetAuthorizersErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_authorizers_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetAuthorizersErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetAuthorizersErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetAuthorizersErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetAuthorizersErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_authorizers_error(
  err: runtime.ClientError,
) -> GetAuthorizersError {
  runtime.translate_service_error(
    err,
    get_authorizers_error_decoders(),
    fn(reason) { GetAuthorizersErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetAuthorizersErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetBasePathMappingError {
  GetBasePathMappingErrorBadRequestException(value: BadRequestException)
  GetBasePathMappingErrorNotFoundException(value: NotFoundException)
  GetBasePathMappingErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  GetBasePathMappingErrorUnauthorizedException(value: UnauthorizedException)
  GetBasePathMappingErrorTransport(reason: String)
  GetBasePathMappingErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_base_path_mapping_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetBasePathMappingErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetBasePathMappingErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetBasePathMappingErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetBasePathMappingErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_base_path_mapping_error(
  err: runtime.ClientError,
) -> GetBasePathMappingError {
  runtime.translate_service_error(
    err,
    get_base_path_mapping_error_decoders(),
    fn(reason) { GetBasePathMappingErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetBasePathMappingErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetBasePathMappingsError {
  GetBasePathMappingsErrorBadRequestException(value: BadRequestException)
  GetBasePathMappingsErrorNotFoundException(value: NotFoundException)
  GetBasePathMappingsErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  GetBasePathMappingsErrorUnauthorizedException(value: UnauthorizedException)
  GetBasePathMappingsErrorTransport(reason: String)
  GetBasePathMappingsErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_base_path_mappings_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetBasePathMappingsErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetBasePathMappingsErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetBasePathMappingsErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetBasePathMappingsErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_base_path_mappings_error(
  err: runtime.ClientError,
) -> GetBasePathMappingsError {
  runtime.translate_service_error(
    err,
    get_base_path_mappings_error_decoders(),
    fn(reason) { GetBasePathMappingsErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetBasePathMappingsErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetClientCertificateError {
  GetClientCertificateErrorBadRequestException(value: BadRequestException)
  GetClientCertificateErrorNotFoundException(value: NotFoundException)
  GetClientCertificateErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  GetClientCertificateErrorUnauthorizedException(value: UnauthorizedException)
  GetClientCertificateErrorTransport(reason: String)
  GetClientCertificateErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn get_client_certificate_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetClientCertificateErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetClientCertificateErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetClientCertificateErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetClientCertificateErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_client_certificate_error(
  err: runtime.ClientError,
) -> GetClientCertificateError {
  runtime.translate_service_error(
    err,
    get_client_certificate_error_decoders(),
    fn(reason) { GetClientCertificateErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetClientCertificateErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetClientCertificatesError {
  GetClientCertificatesErrorBadRequestException(value: BadRequestException)
  GetClientCertificatesErrorNotFoundException(value: NotFoundException)
  GetClientCertificatesErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  GetClientCertificatesErrorUnauthorizedException(value: UnauthorizedException)
  GetClientCertificatesErrorTransport(reason: String)
  GetClientCertificatesErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn get_client_certificates_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetClientCertificatesErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetClientCertificatesErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) ->
          Ok(GetClientCertificatesErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetClientCertificatesErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_client_certificates_error(
  err: runtime.ClientError,
) -> GetClientCertificatesError {
  runtime.translate_service_error(
    err,
    get_client_certificates_error_decoders(),
    fn(reason) { GetClientCertificatesErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetClientCertificatesErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetDeploymentError {
  GetDeploymentErrorBadRequestException(value: BadRequestException)
  GetDeploymentErrorNotFoundException(value: NotFoundException)
  GetDeploymentErrorServiceUnavailableException(
    value: ServiceUnavailableException,
  )
  GetDeploymentErrorTooManyRequestsException(value: TooManyRequestsException)
  GetDeploymentErrorUnauthorizedException(value: UnauthorizedException)
  GetDeploymentErrorTransport(reason: String)
  GetDeploymentErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_deployment_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetDeploymentErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetDeploymentErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ServiceUnavailableException", fn(body) {
      case json.parse(body, decode_service_unavailable_exception_struct()) {
        Ok(v) -> Ok(GetDeploymentErrorServiceUnavailableException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetDeploymentErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetDeploymentErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_deployment_error(
  err: runtime.ClientError,
) -> GetDeploymentError {
  runtime.translate_service_error(
    err,
    get_deployment_error_decoders(),
    fn(reason) { GetDeploymentErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetDeploymentErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetDeploymentsError {
  GetDeploymentsErrorBadRequestException(value: BadRequestException)
  GetDeploymentsErrorNotFoundException(value: NotFoundException)
  GetDeploymentsErrorServiceUnavailableException(
    value: ServiceUnavailableException,
  )
  GetDeploymentsErrorTooManyRequestsException(value: TooManyRequestsException)
  GetDeploymentsErrorUnauthorizedException(value: UnauthorizedException)
  GetDeploymentsErrorTransport(reason: String)
  GetDeploymentsErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_deployments_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetDeploymentsErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetDeploymentsErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ServiceUnavailableException", fn(body) {
      case json.parse(body, decode_service_unavailable_exception_struct()) {
        Ok(v) -> Ok(GetDeploymentsErrorServiceUnavailableException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetDeploymentsErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetDeploymentsErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_deployments_error(
  err: runtime.ClientError,
) -> GetDeploymentsError {
  runtime.translate_service_error(
    err,
    get_deployments_error_decoders(),
    fn(reason) { GetDeploymentsErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetDeploymentsErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetDocumentationPartError {
  GetDocumentationPartErrorBadRequestException(value: BadRequestException)
  GetDocumentationPartErrorNotFoundException(value: NotFoundException)
  GetDocumentationPartErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  GetDocumentationPartErrorUnauthorizedException(value: UnauthorizedException)
  GetDocumentationPartErrorTransport(reason: String)
  GetDocumentationPartErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn get_documentation_part_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetDocumentationPartErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetDocumentationPartErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetDocumentationPartErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetDocumentationPartErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_documentation_part_error(
  err: runtime.ClientError,
) -> GetDocumentationPartError {
  runtime.translate_service_error(
    err,
    get_documentation_part_error_decoders(),
    fn(reason) { GetDocumentationPartErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetDocumentationPartErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetDocumentationPartsError {
  GetDocumentationPartsErrorBadRequestException(value: BadRequestException)
  GetDocumentationPartsErrorNotFoundException(value: NotFoundException)
  GetDocumentationPartsErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  GetDocumentationPartsErrorUnauthorizedException(value: UnauthorizedException)
  GetDocumentationPartsErrorTransport(reason: String)
  GetDocumentationPartsErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn get_documentation_parts_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetDocumentationPartsErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetDocumentationPartsErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) ->
          Ok(GetDocumentationPartsErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetDocumentationPartsErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_documentation_parts_error(
  err: runtime.ClientError,
) -> GetDocumentationPartsError {
  runtime.translate_service_error(
    err,
    get_documentation_parts_error_decoders(),
    fn(reason) { GetDocumentationPartsErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetDocumentationPartsErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetDocumentationVersionError {
  GetDocumentationVersionErrorNotFoundException(value: NotFoundException)
  GetDocumentationVersionErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  GetDocumentationVersionErrorUnauthorizedException(
    value: UnauthorizedException,
  )
  GetDocumentationVersionErrorTransport(reason: String)
  GetDocumentationVersionErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn get_documentation_version_error_decoders() {
  [
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetDocumentationVersionErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) ->
          Ok(GetDocumentationVersionErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetDocumentationVersionErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_documentation_version_error(
  err: runtime.ClientError,
) -> GetDocumentationVersionError {
  runtime.translate_service_error(
    err,
    get_documentation_version_error_decoders(),
    fn(reason) { GetDocumentationVersionErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetDocumentationVersionErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetDocumentationVersionsError {
  GetDocumentationVersionsErrorBadRequestException(value: BadRequestException)
  GetDocumentationVersionsErrorNotFoundException(value: NotFoundException)
  GetDocumentationVersionsErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  GetDocumentationVersionsErrorUnauthorizedException(
    value: UnauthorizedException,
  )
  GetDocumentationVersionsErrorTransport(reason: String)
  GetDocumentationVersionsErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn get_documentation_versions_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetDocumentationVersionsErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetDocumentationVersionsErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) ->
          Ok(GetDocumentationVersionsErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) ->
          Ok(GetDocumentationVersionsErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_documentation_versions_error(
  err: runtime.ClientError,
) -> GetDocumentationVersionsError {
  runtime.translate_service_error(
    err,
    get_documentation_versions_error_decoders(),
    fn(reason) { GetDocumentationVersionsErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetDocumentationVersionsErrorUnknown(
        error_type: et,
        status: s,
        body: body,
      )
    },
  )
}

pub type GetDomainNameError {
  GetDomainNameErrorBadRequestException(value: BadRequestException)
  GetDomainNameErrorNotFoundException(value: NotFoundException)
  GetDomainNameErrorTooManyRequestsException(value: TooManyRequestsException)
  GetDomainNameErrorUnauthorizedException(value: UnauthorizedException)
  GetDomainNameErrorTransport(reason: String)
  GetDomainNameErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_domain_name_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetDomainNameErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetDomainNameErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetDomainNameErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetDomainNameErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_domain_name_error(
  err: runtime.ClientError,
) -> GetDomainNameError {
  runtime.translate_service_error(
    err,
    get_domain_name_error_decoders(),
    fn(reason) { GetDomainNameErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetDomainNameErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetDomainNameAccessAssociationsError {
  GetDomainNameAccessAssociationsErrorBadRequestException(
    value: BadRequestException,
  )
  GetDomainNameAccessAssociationsErrorNotFoundException(
    value: NotFoundException,
  )
  GetDomainNameAccessAssociationsErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  GetDomainNameAccessAssociationsErrorUnauthorizedException(
    value: UnauthorizedException,
  )
  GetDomainNameAccessAssociationsErrorTransport(reason: String)
  GetDomainNameAccessAssociationsErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn get_domain_name_access_associations_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) ->
          Ok(GetDomainNameAccessAssociationsErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) ->
          Ok(GetDomainNameAccessAssociationsErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) ->
          Ok(GetDomainNameAccessAssociationsErrorTooManyRequestsException(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) ->
          Ok(GetDomainNameAccessAssociationsErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_domain_name_access_associations_error(
  err: runtime.ClientError,
) -> GetDomainNameAccessAssociationsError {
  runtime.translate_service_error(
    err,
    get_domain_name_access_associations_error_decoders(),
    fn(reason) { GetDomainNameAccessAssociationsErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetDomainNameAccessAssociationsErrorUnknown(
        error_type: et,
        status: s,
        body: body,
      )
    },
  )
}

pub type GetDomainNamesError {
  GetDomainNamesErrorBadRequestException(value: BadRequestException)
  GetDomainNamesErrorNotFoundException(value: NotFoundException)
  GetDomainNamesErrorTooManyRequestsException(value: TooManyRequestsException)
  GetDomainNamesErrorUnauthorizedException(value: UnauthorizedException)
  GetDomainNamesErrorTransport(reason: String)
  GetDomainNamesErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_domain_names_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetDomainNamesErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetDomainNamesErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetDomainNamesErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetDomainNamesErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_domain_names_error(
  err: runtime.ClientError,
) -> GetDomainNamesError {
  runtime.translate_service_error(
    err,
    get_domain_names_error_decoders(),
    fn(reason) { GetDomainNamesErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetDomainNamesErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetExportError {
  GetExportErrorBadRequestException(value: BadRequestException)
  GetExportErrorConflictException(value: ConflictException)
  GetExportErrorLimitExceededException(value: LimitExceededException)
  GetExportErrorNotFoundException(value: NotFoundException)
  GetExportErrorTooManyRequestsException(value: TooManyRequestsException)
  GetExportErrorUnauthorizedException(value: UnauthorizedException)
  GetExportErrorTransport(reason: String)
  GetExportErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_export_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetExportErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(GetExportErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(GetExportErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetExportErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetExportErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetExportErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_export_error(err: runtime.ClientError) -> GetExportError {
  runtime.translate_service_error(
    err,
    get_export_error_decoders(),
    fn(reason) { GetExportErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetExportErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetGatewayResponseError {
  GetGatewayResponseErrorBadRequestException(value: BadRequestException)
  GetGatewayResponseErrorNotFoundException(value: NotFoundException)
  GetGatewayResponseErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  GetGatewayResponseErrorUnauthorizedException(value: UnauthorizedException)
  GetGatewayResponseErrorTransport(reason: String)
  GetGatewayResponseErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_gateway_response_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetGatewayResponseErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetGatewayResponseErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetGatewayResponseErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetGatewayResponseErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_gateway_response_error(
  err: runtime.ClientError,
) -> GetGatewayResponseError {
  runtime.translate_service_error(
    err,
    get_gateway_response_error_decoders(),
    fn(reason) { GetGatewayResponseErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetGatewayResponseErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetGatewayResponsesError {
  GetGatewayResponsesErrorBadRequestException(value: BadRequestException)
  GetGatewayResponsesErrorNotFoundException(value: NotFoundException)
  GetGatewayResponsesErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  GetGatewayResponsesErrorUnauthorizedException(value: UnauthorizedException)
  GetGatewayResponsesErrorTransport(reason: String)
  GetGatewayResponsesErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_gateway_responses_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetGatewayResponsesErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetGatewayResponsesErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetGatewayResponsesErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetGatewayResponsesErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_gateway_responses_error(
  err: runtime.ClientError,
) -> GetGatewayResponsesError {
  runtime.translate_service_error(
    err,
    get_gateway_responses_error_decoders(),
    fn(reason) { GetGatewayResponsesErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetGatewayResponsesErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetIntegrationError {
  GetIntegrationErrorBadRequestException(value: BadRequestException)
  GetIntegrationErrorNotFoundException(value: NotFoundException)
  GetIntegrationErrorTooManyRequestsException(value: TooManyRequestsException)
  GetIntegrationErrorUnauthorizedException(value: UnauthorizedException)
  GetIntegrationErrorTransport(reason: String)
  GetIntegrationErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_integration_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetIntegrationErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetIntegrationErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetIntegrationErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetIntegrationErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_integration_error(
  err: runtime.ClientError,
) -> GetIntegrationError {
  runtime.translate_service_error(
    err,
    get_integration_error_decoders(),
    fn(reason) { GetIntegrationErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetIntegrationErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetIntegrationResponseError {
  GetIntegrationResponseErrorBadRequestException(value: BadRequestException)
  GetIntegrationResponseErrorNotFoundException(value: NotFoundException)
  GetIntegrationResponseErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  GetIntegrationResponseErrorUnauthorizedException(value: UnauthorizedException)
  GetIntegrationResponseErrorTransport(reason: String)
  GetIntegrationResponseErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn get_integration_response_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetIntegrationResponseErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetIntegrationResponseErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) ->
          Ok(GetIntegrationResponseErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetIntegrationResponseErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_integration_response_error(
  err: runtime.ClientError,
) -> GetIntegrationResponseError {
  runtime.translate_service_error(
    err,
    get_integration_response_error_decoders(),
    fn(reason) { GetIntegrationResponseErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetIntegrationResponseErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetMethodError {
  GetMethodErrorNotFoundException(value: NotFoundException)
  GetMethodErrorTooManyRequestsException(value: TooManyRequestsException)
  GetMethodErrorUnauthorizedException(value: UnauthorizedException)
  GetMethodErrorTransport(reason: String)
  GetMethodErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_method_error_decoders() {
  [
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetMethodErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetMethodErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetMethodErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_method_error(err: runtime.ClientError) -> GetMethodError {
  runtime.translate_service_error(
    err,
    get_method_error_decoders(),
    fn(reason) { GetMethodErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetMethodErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetMethodResponseError {
  GetMethodResponseErrorNotFoundException(value: NotFoundException)
  GetMethodResponseErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  GetMethodResponseErrorUnauthorizedException(value: UnauthorizedException)
  GetMethodResponseErrorTransport(reason: String)
  GetMethodResponseErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_method_response_error_decoders() {
  [
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetMethodResponseErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetMethodResponseErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetMethodResponseErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_method_response_error(
  err: runtime.ClientError,
) -> GetMethodResponseError {
  runtime.translate_service_error(
    err,
    get_method_response_error_decoders(),
    fn(reason) { GetMethodResponseErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetMethodResponseErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetModelError {
  GetModelErrorBadRequestException(value: BadRequestException)
  GetModelErrorNotFoundException(value: NotFoundException)
  GetModelErrorTooManyRequestsException(value: TooManyRequestsException)
  GetModelErrorUnauthorizedException(value: UnauthorizedException)
  GetModelErrorTransport(reason: String)
  GetModelErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_model_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetModelErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetModelErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetModelErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetModelErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_model_error(err: runtime.ClientError) -> GetModelError {
  runtime.translate_service_error(
    err,
    get_model_error_decoders(),
    fn(reason) { GetModelErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetModelErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetModelsError {
  GetModelsErrorBadRequestException(value: BadRequestException)
  GetModelsErrorNotFoundException(value: NotFoundException)
  GetModelsErrorTooManyRequestsException(value: TooManyRequestsException)
  GetModelsErrorUnauthorizedException(value: UnauthorizedException)
  GetModelsErrorTransport(reason: String)
  GetModelsErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_models_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetModelsErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetModelsErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetModelsErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetModelsErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_models_error(err: runtime.ClientError) -> GetModelsError {
  runtime.translate_service_error(
    err,
    get_models_error_decoders(),
    fn(reason) { GetModelsErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetModelsErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetModelTemplateError {
  GetModelTemplateErrorBadRequestException(value: BadRequestException)
  GetModelTemplateErrorNotFoundException(value: NotFoundException)
  GetModelTemplateErrorTooManyRequestsException(value: TooManyRequestsException)
  GetModelTemplateErrorUnauthorizedException(value: UnauthorizedException)
  GetModelTemplateErrorTransport(reason: String)
  GetModelTemplateErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_model_template_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetModelTemplateErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetModelTemplateErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetModelTemplateErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetModelTemplateErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_model_template_error(
  err: runtime.ClientError,
) -> GetModelTemplateError {
  runtime.translate_service_error(
    err,
    get_model_template_error_decoders(),
    fn(reason) { GetModelTemplateErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetModelTemplateErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetRequestValidatorError {
  GetRequestValidatorErrorBadRequestException(value: BadRequestException)
  GetRequestValidatorErrorNotFoundException(value: NotFoundException)
  GetRequestValidatorErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  GetRequestValidatorErrorUnauthorizedException(value: UnauthorizedException)
  GetRequestValidatorErrorTransport(reason: String)
  GetRequestValidatorErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_request_validator_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetRequestValidatorErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetRequestValidatorErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetRequestValidatorErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetRequestValidatorErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_request_validator_error(
  err: runtime.ClientError,
) -> GetRequestValidatorError {
  runtime.translate_service_error(
    err,
    get_request_validator_error_decoders(),
    fn(reason) { GetRequestValidatorErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetRequestValidatorErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetRequestValidatorsError {
  GetRequestValidatorsErrorBadRequestException(value: BadRequestException)
  GetRequestValidatorsErrorNotFoundException(value: NotFoundException)
  GetRequestValidatorsErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  GetRequestValidatorsErrorUnauthorizedException(value: UnauthorizedException)
  GetRequestValidatorsErrorTransport(reason: String)
  GetRequestValidatorsErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn get_request_validators_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetRequestValidatorsErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetRequestValidatorsErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetRequestValidatorsErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetRequestValidatorsErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_request_validators_error(
  err: runtime.ClientError,
) -> GetRequestValidatorsError {
  runtime.translate_service_error(
    err,
    get_request_validators_error_decoders(),
    fn(reason) { GetRequestValidatorsErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetRequestValidatorsErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetResourceError {
  GetResourceErrorNotFoundException(value: NotFoundException)
  GetResourceErrorTooManyRequestsException(value: TooManyRequestsException)
  GetResourceErrorUnauthorizedException(value: UnauthorizedException)
  GetResourceErrorTransport(reason: String)
  GetResourceErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_resource_error_decoders() {
  [
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetResourceErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetResourceErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetResourceErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_resource_error(err: runtime.ClientError) -> GetResourceError {
  runtime.translate_service_error(
    err,
    get_resource_error_decoders(),
    fn(reason) { GetResourceErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetResourceErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetResourcesError {
  GetResourcesErrorBadRequestException(value: BadRequestException)
  GetResourcesErrorNotFoundException(value: NotFoundException)
  GetResourcesErrorTooManyRequestsException(value: TooManyRequestsException)
  GetResourcesErrorUnauthorizedException(value: UnauthorizedException)
  GetResourcesErrorTransport(reason: String)
  GetResourcesErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_resources_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetResourcesErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetResourcesErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetResourcesErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetResourcesErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_resources_error(
  err: runtime.ClientError,
) -> GetResourcesError {
  runtime.translate_service_error(
    err,
    get_resources_error_decoders(),
    fn(reason) { GetResourcesErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetResourcesErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetRestApiError {
  GetRestApiErrorBadRequestException(value: BadRequestException)
  GetRestApiErrorNotFoundException(value: NotFoundException)
  GetRestApiErrorTooManyRequestsException(value: TooManyRequestsException)
  GetRestApiErrorUnauthorizedException(value: UnauthorizedException)
  GetRestApiErrorTransport(reason: String)
  GetRestApiErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_rest_api_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetRestApiErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetRestApiErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetRestApiErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetRestApiErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_rest_api_error(err: runtime.ClientError) -> GetRestApiError {
  runtime.translate_service_error(
    err,
    get_rest_api_error_decoders(),
    fn(reason) { GetRestApiErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetRestApiErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetRestApisError {
  GetRestApisErrorBadRequestException(value: BadRequestException)
  GetRestApisErrorNotFoundException(value: NotFoundException)
  GetRestApisErrorTooManyRequestsException(value: TooManyRequestsException)
  GetRestApisErrorUnauthorizedException(value: UnauthorizedException)
  GetRestApisErrorTransport(reason: String)
  GetRestApisErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_rest_apis_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetRestApisErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetRestApisErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetRestApisErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetRestApisErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_rest_apis_error(err: runtime.ClientError) -> GetRestApisError {
  runtime.translate_service_error(
    err,
    get_rest_apis_error_decoders(),
    fn(reason) { GetRestApisErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetRestApisErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetSdkError {
  GetSdkErrorBadRequestException(value: BadRequestException)
  GetSdkErrorConflictException(value: ConflictException)
  GetSdkErrorLimitExceededException(value: LimitExceededException)
  GetSdkErrorNotFoundException(value: NotFoundException)
  GetSdkErrorTooManyRequestsException(value: TooManyRequestsException)
  GetSdkErrorUnauthorizedException(value: UnauthorizedException)
  GetSdkErrorTransport(reason: String)
  GetSdkErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_sdk_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetSdkErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(GetSdkErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(GetSdkErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetSdkErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetSdkErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetSdkErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_sdk_error(err: runtime.ClientError) -> GetSdkError {
  runtime.translate_service_error(
    err,
    get_sdk_error_decoders(),
    fn(reason) { GetSdkErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetSdkErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetSdkTypeError {
  GetSdkTypeErrorBadRequestException(value: BadRequestException)
  GetSdkTypeErrorNotFoundException(value: NotFoundException)
  GetSdkTypeErrorTooManyRequestsException(value: TooManyRequestsException)
  GetSdkTypeErrorUnauthorizedException(value: UnauthorizedException)
  GetSdkTypeErrorTransport(reason: String)
  GetSdkTypeErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_sdk_type_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetSdkTypeErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetSdkTypeErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetSdkTypeErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetSdkTypeErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_sdk_type_error(err: runtime.ClientError) -> GetSdkTypeError {
  runtime.translate_service_error(
    err,
    get_sdk_type_error_decoders(),
    fn(reason) { GetSdkTypeErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetSdkTypeErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetSdkTypesError {
  GetSdkTypesErrorBadRequestException(value: BadRequestException)
  GetSdkTypesErrorNotFoundException(value: NotFoundException)
  GetSdkTypesErrorTooManyRequestsException(value: TooManyRequestsException)
  GetSdkTypesErrorUnauthorizedException(value: UnauthorizedException)
  GetSdkTypesErrorTransport(reason: String)
  GetSdkTypesErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_sdk_types_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetSdkTypesErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetSdkTypesErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetSdkTypesErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetSdkTypesErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_sdk_types_error(err: runtime.ClientError) -> GetSdkTypesError {
  runtime.translate_service_error(
    err,
    get_sdk_types_error_decoders(),
    fn(reason) { GetSdkTypesErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetSdkTypesErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetStageError {
  GetStageErrorBadRequestException(value: BadRequestException)
  GetStageErrorConflictException(value: ConflictException)
  GetStageErrorLimitExceededException(value: LimitExceededException)
  GetStageErrorNotFoundException(value: NotFoundException)
  GetStageErrorTooManyRequestsException(value: TooManyRequestsException)
  GetStageErrorUnauthorizedException(value: UnauthorizedException)
  GetStageErrorTransport(reason: String)
  GetStageErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_stage_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetStageErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(GetStageErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(GetStageErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetStageErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetStageErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetStageErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_stage_error(err: runtime.ClientError) -> GetStageError {
  runtime.translate_service_error(
    err,
    get_stage_error_decoders(),
    fn(reason) { GetStageErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetStageErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetStagesError {
  GetStagesErrorBadRequestException(value: BadRequestException)
  GetStagesErrorConflictException(value: ConflictException)
  GetStagesErrorLimitExceededException(value: LimitExceededException)
  GetStagesErrorNotFoundException(value: NotFoundException)
  GetStagesErrorTooManyRequestsException(value: TooManyRequestsException)
  GetStagesErrorUnauthorizedException(value: UnauthorizedException)
  GetStagesErrorTransport(reason: String)
  GetStagesErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_stages_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetStagesErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(GetStagesErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(GetStagesErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetStagesErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetStagesErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetStagesErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_stages_error(err: runtime.ClientError) -> GetStagesError {
  runtime.translate_service_error(
    err,
    get_stages_error_decoders(),
    fn(reason) { GetStagesErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetStagesErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetTagsError {
  GetTagsErrorBadRequestException(value: BadRequestException)
  GetTagsErrorNotFoundException(value: NotFoundException)
  GetTagsErrorTooManyRequestsException(value: TooManyRequestsException)
  GetTagsErrorUnauthorizedException(value: UnauthorizedException)
  GetTagsErrorTransport(reason: String)
  GetTagsErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_tags_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetTagsErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetTagsErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetTagsErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetTagsErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_tags_error(err: runtime.ClientError) -> GetTagsError {
  runtime.translate_service_error(
    err,
    get_tags_error_decoders(),
    fn(reason) { GetTagsErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetTagsErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetUsageError {
  GetUsageErrorBadRequestException(value: BadRequestException)
  GetUsageErrorNotFoundException(value: NotFoundException)
  GetUsageErrorTooManyRequestsException(value: TooManyRequestsException)
  GetUsageErrorUnauthorizedException(value: UnauthorizedException)
  GetUsageErrorTransport(reason: String)
  GetUsageErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_usage_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetUsageErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetUsageErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetUsageErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetUsageErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_usage_error(err: runtime.ClientError) -> GetUsageError {
  runtime.translate_service_error(
    err,
    get_usage_error_decoders(),
    fn(reason) { GetUsageErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetUsageErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetUsagePlanError {
  GetUsagePlanErrorBadRequestException(value: BadRequestException)
  GetUsagePlanErrorNotFoundException(value: NotFoundException)
  GetUsagePlanErrorTooManyRequestsException(value: TooManyRequestsException)
  GetUsagePlanErrorUnauthorizedException(value: UnauthorizedException)
  GetUsagePlanErrorTransport(reason: String)
  GetUsagePlanErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_usage_plan_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetUsagePlanErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetUsagePlanErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetUsagePlanErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetUsagePlanErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_usage_plan_error(
  err: runtime.ClientError,
) -> GetUsagePlanError {
  runtime.translate_service_error(
    err,
    get_usage_plan_error_decoders(),
    fn(reason) { GetUsagePlanErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetUsagePlanErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetUsagePlanKeyError {
  GetUsagePlanKeyErrorBadRequestException(value: BadRequestException)
  GetUsagePlanKeyErrorNotFoundException(value: NotFoundException)
  GetUsagePlanKeyErrorTooManyRequestsException(value: TooManyRequestsException)
  GetUsagePlanKeyErrorUnauthorizedException(value: UnauthorizedException)
  GetUsagePlanKeyErrorTransport(reason: String)
  GetUsagePlanKeyErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_usage_plan_key_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetUsagePlanKeyErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetUsagePlanKeyErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetUsagePlanKeyErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetUsagePlanKeyErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_usage_plan_key_error(
  err: runtime.ClientError,
) -> GetUsagePlanKeyError {
  runtime.translate_service_error(
    err,
    get_usage_plan_key_error_decoders(),
    fn(reason) { GetUsagePlanKeyErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetUsagePlanKeyErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetUsagePlanKeysError {
  GetUsagePlanKeysErrorBadRequestException(value: BadRequestException)
  GetUsagePlanKeysErrorNotFoundException(value: NotFoundException)
  GetUsagePlanKeysErrorTooManyRequestsException(value: TooManyRequestsException)
  GetUsagePlanKeysErrorUnauthorizedException(value: UnauthorizedException)
  GetUsagePlanKeysErrorTransport(reason: String)
  GetUsagePlanKeysErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_usage_plan_keys_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetUsagePlanKeysErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetUsagePlanKeysErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetUsagePlanKeysErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetUsagePlanKeysErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_usage_plan_keys_error(
  err: runtime.ClientError,
) -> GetUsagePlanKeysError {
  runtime.translate_service_error(
    err,
    get_usage_plan_keys_error_decoders(),
    fn(reason) { GetUsagePlanKeysErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetUsagePlanKeysErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetUsagePlansError {
  GetUsagePlansErrorBadRequestException(value: BadRequestException)
  GetUsagePlansErrorNotFoundException(value: NotFoundException)
  GetUsagePlansErrorTooManyRequestsException(value: TooManyRequestsException)
  GetUsagePlansErrorUnauthorizedException(value: UnauthorizedException)
  GetUsagePlansErrorTransport(reason: String)
  GetUsagePlansErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_usage_plans_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetUsagePlansErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetUsagePlansErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetUsagePlansErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetUsagePlansErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_usage_plans_error(
  err: runtime.ClientError,
) -> GetUsagePlansError {
  runtime.translate_service_error(
    err,
    get_usage_plans_error_decoders(),
    fn(reason) { GetUsagePlansErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetUsagePlansErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetVpcLinkError {
  GetVpcLinkErrorBadRequestException(value: BadRequestException)
  GetVpcLinkErrorNotFoundException(value: NotFoundException)
  GetVpcLinkErrorTooManyRequestsException(value: TooManyRequestsException)
  GetVpcLinkErrorUnauthorizedException(value: UnauthorizedException)
  GetVpcLinkErrorTransport(reason: String)
  GetVpcLinkErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_vpc_link_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetVpcLinkErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetVpcLinkErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetVpcLinkErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetVpcLinkErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_vpc_link_error(err: runtime.ClientError) -> GetVpcLinkError {
  runtime.translate_service_error(
    err,
    get_vpc_link_error_decoders(),
    fn(reason) { GetVpcLinkErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetVpcLinkErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type GetVpcLinksError {
  GetVpcLinksErrorBadRequestException(value: BadRequestException)
  GetVpcLinksErrorNotFoundException(value: NotFoundException)
  GetVpcLinksErrorTooManyRequestsException(value: TooManyRequestsException)
  GetVpcLinksErrorUnauthorizedException(value: UnauthorizedException)
  GetVpcLinksErrorTransport(reason: String)
  GetVpcLinksErrorUnknown(error_type: String, status: Int, body: String)
}

fn get_vpc_links_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(GetVpcLinksErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(GetVpcLinksErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(GetVpcLinksErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(GetVpcLinksErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_get_vpc_links_error(err: runtime.ClientError) -> GetVpcLinksError {
  runtime.translate_service_error(
    err,
    get_vpc_links_error_decoders(),
    fn(reason) { GetVpcLinksErrorTransport(reason: reason) },
    fn(et, s, body) {
      GetVpcLinksErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type ImportApiKeysError {
  ImportApiKeysErrorBadRequestException(value: BadRequestException)
  ImportApiKeysErrorConflictException(value: ConflictException)
  ImportApiKeysErrorLimitExceededException(value: LimitExceededException)
  ImportApiKeysErrorNotFoundException(value: NotFoundException)
  ImportApiKeysErrorTooManyRequestsException(value: TooManyRequestsException)
  ImportApiKeysErrorUnauthorizedException(value: UnauthorizedException)
  ImportApiKeysErrorTransport(reason: String)
  ImportApiKeysErrorUnknown(error_type: String, status: Int, body: String)
}

fn import_api_keys_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(ImportApiKeysErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(ImportApiKeysErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(ImportApiKeysErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(ImportApiKeysErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(ImportApiKeysErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(ImportApiKeysErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_import_api_keys_error(
  err: runtime.ClientError,
) -> ImportApiKeysError {
  runtime.translate_service_error(
    err,
    import_api_keys_error_decoders(),
    fn(reason) { ImportApiKeysErrorTransport(reason: reason) },
    fn(et, s, body) {
      ImportApiKeysErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type ImportDocumentationPartsError {
  ImportDocumentationPartsErrorBadRequestException(value: BadRequestException)
  ImportDocumentationPartsErrorConflictException(value: ConflictException)
  ImportDocumentationPartsErrorLimitExceededException(
    value: LimitExceededException,
  )
  ImportDocumentationPartsErrorNotFoundException(value: NotFoundException)
  ImportDocumentationPartsErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  ImportDocumentationPartsErrorUnauthorizedException(
    value: UnauthorizedException,
  )
  ImportDocumentationPartsErrorTransport(reason: String)
  ImportDocumentationPartsErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn import_documentation_parts_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(ImportDocumentationPartsErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(ImportDocumentationPartsErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) ->
          Ok(ImportDocumentationPartsErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(ImportDocumentationPartsErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) ->
          Ok(ImportDocumentationPartsErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) ->
          Ok(ImportDocumentationPartsErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_import_documentation_parts_error(
  err: runtime.ClientError,
) -> ImportDocumentationPartsError {
  runtime.translate_service_error(
    err,
    import_documentation_parts_error_decoders(),
    fn(reason) { ImportDocumentationPartsErrorTransport(reason: reason) },
    fn(et, s, body) {
      ImportDocumentationPartsErrorUnknown(
        error_type: et,
        status: s,
        body: body,
      )
    },
  )
}

pub type ImportRestApiError {
  ImportRestApiErrorBadRequestException(value: BadRequestException)
  ImportRestApiErrorConflictException(value: ConflictException)
  ImportRestApiErrorLimitExceededException(value: LimitExceededException)
  ImportRestApiErrorNotFoundException(value: NotFoundException)
  ImportRestApiErrorTooManyRequestsException(value: TooManyRequestsException)
  ImportRestApiErrorUnauthorizedException(value: UnauthorizedException)
  ImportRestApiErrorTransport(reason: String)
  ImportRestApiErrorUnknown(error_type: String, status: Int, body: String)
}

fn import_rest_api_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(ImportRestApiErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(ImportRestApiErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(ImportRestApiErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(ImportRestApiErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(ImportRestApiErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(ImportRestApiErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_import_rest_api_error(
  err: runtime.ClientError,
) -> ImportRestApiError {
  runtime.translate_service_error(
    err,
    import_rest_api_error_decoders(),
    fn(reason) { ImportRestApiErrorTransport(reason: reason) },
    fn(et, s, body) {
      ImportRestApiErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type PutGatewayResponseError {
  PutGatewayResponseErrorBadRequestException(value: BadRequestException)
  PutGatewayResponseErrorConflictException(value: ConflictException)
  PutGatewayResponseErrorLimitExceededException(value: LimitExceededException)
  PutGatewayResponseErrorNotFoundException(value: NotFoundException)
  PutGatewayResponseErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  PutGatewayResponseErrorUnauthorizedException(value: UnauthorizedException)
  PutGatewayResponseErrorTransport(reason: String)
  PutGatewayResponseErrorUnknown(error_type: String, status: Int, body: String)
}

fn put_gateway_response_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(PutGatewayResponseErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(PutGatewayResponseErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(PutGatewayResponseErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(PutGatewayResponseErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(PutGatewayResponseErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(PutGatewayResponseErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_put_gateway_response_error(
  err: runtime.ClientError,
) -> PutGatewayResponseError {
  runtime.translate_service_error(
    err,
    put_gateway_response_error_decoders(),
    fn(reason) { PutGatewayResponseErrorTransport(reason: reason) },
    fn(et, s, body) {
      PutGatewayResponseErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type PutIntegrationError {
  PutIntegrationErrorBadRequestException(value: BadRequestException)
  PutIntegrationErrorConflictException(value: ConflictException)
  PutIntegrationErrorLimitExceededException(value: LimitExceededException)
  PutIntegrationErrorNotFoundException(value: NotFoundException)
  PutIntegrationErrorTooManyRequestsException(value: TooManyRequestsException)
  PutIntegrationErrorUnauthorizedException(value: UnauthorizedException)
  PutIntegrationErrorTransport(reason: String)
  PutIntegrationErrorUnknown(error_type: String, status: Int, body: String)
}

fn put_integration_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(PutIntegrationErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(PutIntegrationErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(PutIntegrationErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(PutIntegrationErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(PutIntegrationErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(PutIntegrationErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_put_integration_error(
  err: runtime.ClientError,
) -> PutIntegrationError {
  runtime.translate_service_error(
    err,
    put_integration_error_decoders(),
    fn(reason) { PutIntegrationErrorTransport(reason: reason) },
    fn(et, s, body) {
      PutIntegrationErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type PutIntegrationResponseError {
  PutIntegrationResponseErrorBadRequestException(value: BadRequestException)
  PutIntegrationResponseErrorConflictException(value: ConflictException)
  PutIntegrationResponseErrorLimitExceededException(
    value: LimitExceededException,
  )
  PutIntegrationResponseErrorNotFoundException(value: NotFoundException)
  PutIntegrationResponseErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  PutIntegrationResponseErrorUnauthorizedException(value: UnauthorizedException)
  PutIntegrationResponseErrorTransport(reason: String)
  PutIntegrationResponseErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn put_integration_response_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(PutIntegrationResponseErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(PutIntegrationResponseErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(PutIntegrationResponseErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(PutIntegrationResponseErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) ->
          Ok(PutIntegrationResponseErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(PutIntegrationResponseErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_put_integration_response_error(
  err: runtime.ClientError,
) -> PutIntegrationResponseError {
  runtime.translate_service_error(
    err,
    put_integration_response_error_decoders(),
    fn(reason) { PutIntegrationResponseErrorTransport(reason: reason) },
    fn(et, s, body) {
      PutIntegrationResponseErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type PutMethodError {
  PutMethodErrorBadRequestException(value: BadRequestException)
  PutMethodErrorConflictException(value: ConflictException)
  PutMethodErrorLimitExceededException(value: LimitExceededException)
  PutMethodErrorNotFoundException(value: NotFoundException)
  PutMethodErrorTooManyRequestsException(value: TooManyRequestsException)
  PutMethodErrorUnauthorizedException(value: UnauthorizedException)
  PutMethodErrorTransport(reason: String)
  PutMethodErrorUnknown(error_type: String, status: Int, body: String)
}

fn put_method_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(PutMethodErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(PutMethodErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(PutMethodErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(PutMethodErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(PutMethodErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(PutMethodErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_put_method_error(err: runtime.ClientError) -> PutMethodError {
  runtime.translate_service_error(
    err,
    put_method_error_decoders(),
    fn(reason) { PutMethodErrorTransport(reason: reason) },
    fn(et, s, body) {
      PutMethodErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type PutMethodResponseError {
  PutMethodResponseErrorBadRequestException(value: BadRequestException)
  PutMethodResponseErrorConflictException(value: ConflictException)
  PutMethodResponseErrorLimitExceededException(value: LimitExceededException)
  PutMethodResponseErrorNotFoundException(value: NotFoundException)
  PutMethodResponseErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  PutMethodResponseErrorUnauthorizedException(value: UnauthorizedException)
  PutMethodResponseErrorTransport(reason: String)
  PutMethodResponseErrorUnknown(error_type: String, status: Int, body: String)
}

fn put_method_response_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(PutMethodResponseErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(PutMethodResponseErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(PutMethodResponseErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(PutMethodResponseErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(PutMethodResponseErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(PutMethodResponseErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_put_method_response_error(
  err: runtime.ClientError,
) -> PutMethodResponseError {
  runtime.translate_service_error(
    err,
    put_method_response_error_decoders(),
    fn(reason) { PutMethodResponseErrorTransport(reason: reason) },
    fn(et, s, body) {
      PutMethodResponseErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type PutRestApiError {
  PutRestApiErrorBadRequestException(value: BadRequestException)
  PutRestApiErrorConflictException(value: ConflictException)
  PutRestApiErrorLimitExceededException(value: LimitExceededException)
  PutRestApiErrorNotFoundException(value: NotFoundException)
  PutRestApiErrorTooManyRequestsException(value: TooManyRequestsException)
  PutRestApiErrorUnauthorizedException(value: UnauthorizedException)
  PutRestApiErrorTransport(reason: String)
  PutRestApiErrorUnknown(error_type: String, status: Int, body: String)
}

fn put_rest_api_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(PutRestApiErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(PutRestApiErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(PutRestApiErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(PutRestApiErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(PutRestApiErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(PutRestApiErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_put_rest_api_error(err: runtime.ClientError) -> PutRestApiError {
  runtime.translate_service_error(
    err,
    put_rest_api_error_decoders(),
    fn(reason) { PutRestApiErrorTransport(reason: reason) },
    fn(et, s, body) {
      PutRestApiErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type RejectDomainNameAccessAssociationError {
  RejectDomainNameAccessAssociationErrorBadRequestException(
    value: BadRequestException,
  )
  RejectDomainNameAccessAssociationErrorConflictException(
    value: ConflictException,
  )
  RejectDomainNameAccessAssociationErrorNotFoundException(
    value: NotFoundException,
  )
  RejectDomainNameAccessAssociationErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  RejectDomainNameAccessAssociationErrorUnauthorizedException(
    value: UnauthorizedException,
  )
  RejectDomainNameAccessAssociationErrorTransport(reason: String)
  RejectDomainNameAccessAssociationErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn reject_domain_name_access_association_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) ->
          Ok(RejectDomainNameAccessAssociationErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) ->
          Ok(RejectDomainNameAccessAssociationErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) ->
          Ok(RejectDomainNameAccessAssociationErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) ->
          Ok(RejectDomainNameAccessAssociationErrorTooManyRequestsException(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) ->
          Ok(RejectDomainNameAccessAssociationErrorUnauthorizedException(
            value: v,
          ))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_reject_domain_name_access_association_error(
  err: runtime.ClientError,
) -> RejectDomainNameAccessAssociationError {
  runtime.translate_service_error(
    err,
    reject_domain_name_access_association_error_decoders(),
    fn(reason) {
      RejectDomainNameAccessAssociationErrorTransport(reason: reason)
    },
    fn(et, s, body) {
      RejectDomainNameAccessAssociationErrorUnknown(
        error_type: et,
        status: s,
        body: body,
      )
    },
  )
}

pub type TagResourceError {
  TagResourceErrorBadRequestException(value: BadRequestException)
  TagResourceErrorConflictException(value: ConflictException)
  TagResourceErrorLimitExceededException(value: LimitExceededException)
  TagResourceErrorNotFoundException(value: NotFoundException)
  TagResourceErrorTooManyRequestsException(value: TooManyRequestsException)
  TagResourceErrorUnauthorizedException(value: UnauthorizedException)
  TagResourceErrorTransport(reason: String)
  TagResourceErrorUnknown(error_type: String, status: Int, body: String)
}

fn tag_resource_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(TagResourceErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(TagResourceErrorConflictException(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)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(TagResourceErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(TagResourceErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(TagResourceErrorUnauthorizedException(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 type TestInvokeAuthorizerError {
  TestInvokeAuthorizerErrorBadRequestException(value: BadRequestException)
  TestInvokeAuthorizerErrorNotFoundException(value: NotFoundException)
  TestInvokeAuthorizerErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  TestInvokeAuthorizerErrorUnauthorizedException(value: UnauthorizedException)
  TestInvokeAuthorizerErrorTransport(reason: String)
  TestInvokeAuthorizerErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn test_invoke_authorizer_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(TestInvokeAuthorizerErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(TestInvokeAuthorizerErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(TestInvokeAuthorizerErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(TestInvokeAuthorizerErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_test_invoke_authorizer_error(
  err: runtime.ClientError,
) -> TestInvokeAuthorizerError {
  runtime.translate_service_error(
    err,
    test_invoke_authorizer_error_decoders(),
    fn(reason) { TestInvokeAuthorizerErrorTransport(reason: reason) },
    fn(et, s, body) {
      TestInvokeAuthorizerErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type TestInvokeMethodError {
  TestInvokeMethodErrorBadRequestException(value: BadRequestException)
  TestInvokeMethodErrorNotFoundException(value: NotFoundException)
  TestInvokeMethodErrorTooManyRequestsException(value: TooManyRequestsException)
  TestInvokeMethodErrorUnauthorizedException(value: UnauthorizedException)
  TestInvokeMethodErrorTransport(reason: String)
  TestInvokeMethodErrorUnknown(error_type: String, status: Int, body: String)
}

fn test_invoke_method_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(TestInvokeMethodErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(TestInvokeMethodErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(TestInvokeMethodErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(TestInvokeMethodErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_test_invoke_method_error(
  err: runtime.ClientError,
) -> TestInvokeMethodError {
  runtime.translate_service_error(
    err,
    test_invoke_method_error_decoders(),
    fn(reason) { TestInvokeMethodErrorTransport(reason: reason) },
    fn(et, s, body) {
      TestInvokeMethodErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type UntagResourceError {
  UntagResourceErrorBadRequestException(value: BadRequestException)
  UntagResourceErrorConflictException(value: ConflictException)
  UntagResourceErrorLimitExceededException(value: LimitExceededException)
  UntagResourceErrorNotFoundException(value: NotFoundException)
  UntagResourceErrorTooManyRequestsException(value: TooManyRequestsException)
  UntagResourceErrorUnauthorizedException(value: UnauthorizedException)
  UntagResourceErrorTransport(reason: String)
  UntagResourceErrorUnknown(error_type: String, status: Int, body: String)
}

fn untag_resource_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(UntagResourceErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(UntagResourceErrorConflictException(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)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(UntagResourceErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(UntagResourceErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(UntagResourceErrorUnauthorizedException(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 type UpdateAccountError {
  UpdateAccountErrorBadRequestException(value: BadRequestException)
  UpdateAccountErrorConflictException(value: ConflictException)
  UpdateAccountErrorLimitExceededException(value: LimitExceededException)
  UpdateAccountErrorNotFoundException(value: NotFoundException)
  UpdateAccountErrorTooManyRequestsException(value: TooManyRequestsException)
  UpdateAccountErrorUnauthorizedException(value: UnauthorizedException)
  UpdateAccountErrorTransport(reason: String)
  UpdateAccountErrorUnknown(error_type: String, status: Int, body: String)
}

fn update_account_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(UpdateAccountErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(UpdateAccountErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(UpdateAccountErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(UpdateAccountErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(UpdateAccountErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(UpdateAccountErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_update_account_error(
  err: runtime.ClientError,
) -> UpdateAccountError {
  runtime.translate_service_error(
    err,
    update_account_error_decoders(),
    fn(reason) { UpdateAccountErrorTransport(reason: reason) },
    fn(et, s, body) {
      UpdateAccountErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type UpdateApiKeyError {
  UpdateApiKeyErrorBadRequestException(value: BadRequestException)
  UpdateApiKeyErrorConflictException(value: ConflictException)
  UpdateApiKeyErrorLimitExceededException(value: LimitExceededException)
  UpdateApiKeyErrorNotFoundException(value: NotFoundException)
  UpdateApiKeyErrorTooManyRequestsException(value: TooManyRequestsException)
  UpdateApiKeyErrorUnauthorizedException(value: UnauthorizedException)
  UpdateApiKeyErrorTransport(reason: String)
  UpdateApiKeyErrorUnknown(error_type: String, status: Int, body: String)
}

fn update_api_key_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(UpdateApiKeyErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(UpdateApiKeyErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(UpdateApiKeyErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(UpdateApiKeyErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(UpdateApiKeyErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(UpdateApiKeyErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_update_api_key_error(
  err: runtime.ClientError,
) -> UpdateApiKeyError {
  runtime.translate_service_error(
    err,
    update_api_key_error_decoders(),
    fn(reason) { UpdateApiKeyErrorTransport(reason: reason) },
    fn(et, s, body) {
      UpdateApiKeyErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type UpdateAuthorizerError {
  UpdateAuthorizerErrorBadRequestException(value: BadRequestException)
  UpdateAuthorizerErrorConflictException(value: ConflictException)
  UpdateAuthorizerErrorLimitExceededException(value: LimitExceededException)
  UpdateAuthorizerErrorNotFoundException(value: NotFoundException)
  UpdateAuthorizerErrorTooManyRequestsException(value: TooManyRequestsException)
  UpdateAuthorizerErrorUnauthorizedException(value: UnauthorizedException)
  UpdateAuthorizerErrorTransport(reason: String)
  UpdateAuthorizerErrorUnknown(error_type: String, status: Int, body: String)
}

fn update_authorizer_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(UpdateAuthorizerErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(UpdateAuthorizerErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(UpdateAuthorizerErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(UpdateAuthorizerErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(UpdateAuthorizerErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(UpdateAuthorizerErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_update_authorizer_error(
  err: runtime.ClientError,
) -> UpdateAuthorizerError {
  runtime.translate_service_error(
    err,
    update_authorizer_error_decoders(),
    fn(reason) { UpdateAuthorizerErrorTransport(reason: reason) },
    fn(et, s, body) {
      UpdateAuthorizerErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type UpdateBasePathMappingError {
  UpdateBasePathMappingErrorBadRequestException(value: BadRequestException)
  UpdateBasePathMappingErrorConflictException(value: ConflictException)
  UpdateBasePathMappingErrorLimitExceededException(
    value: LimitExceededException,
  )
  UpdateBasePathMappingErrorNotFoundException(value: NotFoundException)
  UpdateBasePathMappingErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  UpdateBasePathMappingErrorUnauthorizedException(value: UnauthorizedException)
  UpdateBasePathMappingErrorTransport(reason: String)
  UpdateBasePathMappingErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn update_base_path_mapping_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(UpdateBasePathMappingErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(UpdateBasePathMappingErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(UpdateBasePathMappingErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(UpdateBasePathMappingErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) ->
          Ok(UpdateBasePathMappingErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(UpdateBasePathMappingErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_update_base_path_mapping_error(
  err: runtime.ClientError,
) -> UpdateBasePathMappingError {
  runtime.translate_service_error(
    err,
    update_base_path_mapping_error_decoders(),
    fn(reason) { UpdateBasePathMappingErrorTransport(reason: reason) },
    fn(et, s, body) {
      UpdateBasePathMappingErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type UpdateClientCertificateError {
  UpdateClientCertificateErrorBadRequestException(value: BadRequestException)
  UpdateClientCertificateErrorConflictException(value: ConflictException)
  UpdateClientCertificateErrorLimitExceededException(
    value: LimitExceededException,
  )
  UpdateClientCertificateErrorNotFoundException(value: NotFoundException)
  UpdateClientCertificateErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  UpdateClientCertificateErrorUnauthorizedException(
    value: UnauthorizedException,
  )
  UpdateClientCertificateErrorTransport(reason: String)
  UpdateClientCertificateErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn update_client_certificate_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(UpdateClientCertificateErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(UpdateClientCertificateErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) ->
          Ok(UpdateClientCertificateErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(UpdateClientCertificateErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) ->
          Ok(UpdateClientCertificateErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(UpdateClientCertificateErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_update_client_certificate_error(
  err: runtime.ClientError,
) -> UpdateClientCertificateError {
  runtime.translate_service_error(
    err,
    update_client_certificate_error_decoders(),
    fn(reason) { UpdateClientCertificateErrorTransport(reason: reason) },
    fn(et, s, body) {
      UpdateClientCertificateErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type UpdateDeploymentError {
  UpdateDeploymentErrorBadRequestException(value: BadRequestException)
  UpdateDeploymentErrorConflictException(value: ConflictException)
  UpdateDeploymentErrorLimitExceededException(value: LimitExceededException)
  UpdateDeploymentErrorNotFoundException(value: NotFoundException)
  UpdateDeploymentErrorServiceUnavailableException(
    value: ServiceUnavailableException,
  )
  UpdateDeploymentErrorTooManyRequestsException(value: TooManyRequestsException)
  UpdateDeploymentErrorUnauthorizedException(value: UnauthorizedException)
  UpdateDeploymentErrorTransport(reason: String)
  UpdateDeploymentErrorUnknown(error_type: String, status: Int, body: String)
}

fn update_deployment_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(UpdateDeploymentErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(UpdateDeploymentErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(UpdateDeploymentErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(UpdateDeploymentErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ServiceUnavailableException", fn(body) {
      case json.parse(body, decode_service_unavailable_exception_struct()) {
        Ok(v) -> Ok(UpdateDeploymentErrorServiceUnavailableException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(UpdateDeploymentErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(UpdateDeploymentErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_update_deployment_error(
  err: runtime.ClientError,
) -> UpdateDeploymentError {
  runtime.translate_service_error(
    err,
    update_deployment_error_decoders(),
    fn(reason) { UpdateDeploymentErrorTransport(reason: reason) },
    fn(et, s, body) {
      UpdateDeploymentErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type UpdateDocumentationPartError {
  UpdateDocumentationPartErrorBadRequestException(value: BadRequestException)
  UpdateDocumentationPartErrorConflictException(value: ConflictException)
  UpdateDocumentationPartErrorLimitExceededException(
    value: LimitExceededException,
  )
  UpdateDocumentationPartErrorNotFoundException(value: NotFoundException)
  UpdateDocumentationPartErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  UpdateDocumentationPartErrorUnauthorizedException(
    value: UnauthorizedException,
  )
  UpdateDocumentationPartErrorTransport(reason: String)
  UpdateDocumentationPartErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn update_documentation_part_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(UpdateDocumentationPartErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(UpdateDocumentationPartErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) ->
          Ok(UpdateDocumentationPartErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(UpdateDocumentationPartErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) ->
          Ok(UpdateDocumentationPartErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(UpdateDocumentationPartErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_update_documentation_part_error(
  err: runtime.ClientError,
) -> UpdateDocumentationPartError {
  runtime.translate_service_error(
    err,
    update_documentation_part_error_decoders(),
    fn(reason) { UpdateDocumentationPartErrorTransport(reason: reason) },
    fn(et, s, body) {
      UpdateDocumentationPartErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type UpdateDocumentationVersionError {
  UpdateDocumentationVersionErrorBadRequestException(value: BadRequestException)
  UpdateDocumentationVersionErrorConflictException(value: ConflictException)
  UpdateDocumentationVersionErrorLimitExceededException(
    value: LimitExceededException,
  )
  UpdateDocumentationVersionErrorNotFoundException(value: NotFoundException)
  UpdateDocumentationVersionErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  UpdateDocumentationVersionErrorUnauthorizedException(
    value: UnauthorizedException,
  )
  UpdateDocumentationVersionErrorTransport(reason: String)
  UpdateDocumentationVersionErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn update_documentation_version_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) ->
          Ok(UpdateDocumentationVersionErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(UpdateDocumentationVersionErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) ->
          Ok(UpdateDocumentationVersionErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(UpdateDocumentationVersionErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) ->
          Ok(UpdateDocumentationVersionErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) ->
          Ok(UpdateDocumentationVersionErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_update_documentation_version_error(
  err: runtime.ClientError,
) -> UpdateDocumentationVersionError {
  runtime.translate_service_error(
    err,
    update_documentation_version_error_decoders(),
    fn(reason) { UpdateDocumentationVersionErrorTransport(reason: reason) },
    fn(et, s, body) {
      UpdateDocumentationVersionErrorUnknown(
        error_type: et,
        status: s,
        body: body,
      )
    },
  )
}

pub type UpdateDomainNameError {
  UpdateDomainNameErrorBadRequestException(value: BadRequestException)
  UpdateDomainNameErrorConflictException(value: ConflictException)
  UpdateDomainNameErrorLimitExceededException(value: LimitExceededException)
  UpdateDomainNameErrorNotFoundException(value: NotFoundException)
  UpdateDomainNameErrorTooManyRequestsException(value: TooManyRequestsException)
  UpdateDomainNameErrorUnauthorizedException(value: UnauthorizedException)
  UpdateDomainNameErrorTransport(reason: String)
  UpdateDomainNameErrorUnknown(error_type: String, status: Int, body: String)
}

fn update_domain_name_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(UpdateDomainNameErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(UpdateDomainNameErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(UpdateDomainNameErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(UpdateDomainNameErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(UpdateDomainNameErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(UpdateDomainNameErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_update_domain_name_error(
  err: runtime.ClientError,
) -> UpdateDomainNameError {
  runtime.translate_service_error(
    err,
    update_domain_name_error_decoders(),
    fn(reason) { UpdateDomainNameErrorTransport(reason: reason) },
    fn(et, s, body) {
      UpdateDomainNameErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type UpdateGatewayResponseError {
  UpdateGatewayResponseErrorBadRequestException(value: BadRequestException)
  UpdateGatewayResponseErrorConflictException(value: ConflictException)
  UpdateGatewayResponseErrorLimitExceededException(
    value: LimitExceededException,
  )
  UpdateGatewayResponseErrorNotFoundException(value: NotFoundException)
  UpdateGatewayResponseErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  UpdateGatewayResponseErrorUnauthorizedException(value: UnauthorizedException)
  UpdateGatewayResponseErrorTransport(reason: String)
  UpdateGatewayResponseErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn update_gateway_response_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(UpdateGatewayResponseErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(UpdateGatewayResponseErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(UpdateGatewayResponseErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(UpdateGatewayResponseErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) ->
          Ok(UpdateGatewayResponseErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(UpdateGatewayResponseErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_update_gateway_response_error(
  err: runtime.ClientError,
) -> UpdateGatewayResponseError {
  runtime.translate_service_error(
    err,
    update_gateway_response_error_decoders(),
    fn(reason) { UpdateGatewayResponseErrorTransport(reason: reason) },
    fn(et, s, body) {
      UpdateGatewayResponseErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type UpdateIntegrationError {
  UpdateIntegrationErrorBadRequestException(value: BadRequestException)
  UpdateIntegrationErrorConflictException(value: ConflictException)
  UpdateIntegrationErrorLimitExceededException(value: LimitExceededException)
  UpdateIntegrationErrorNotFoundException(value: NotFoundException)
  UpdateIntegrationErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  UpdateIntegrationErrorUnauthorizedException(value: UnauthorizedException)
  UpdateIntegrationErrorTransport(reason: String)
  UpdateIntegrationErrorUnknown(error_type: String, status: Int, body: String)
}

fn update_integration_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(UpdateIntegrationErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(UpdateIntegrationErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(UpdateIntegrationErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(UpdateIntegrationErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(UpdateIntegrationErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(UpdateIntegrationErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_update_integration_error(
  err: runtime.ClientError,
) -> UpdateIntegrationError {
  runtime.translate_service_error(
    err,
    update_integration_error_decoders(),
    fn(reason) { UpdateIntegrationErrorTransport(reason: reason) },
    fn(et, s, body) {
      UpdateIntegrationErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type UpdateIntegrationResponseError {
  UpdateIntegrationResponseErrorBadRequestException(value: BadRequestException)
  UpdateIntegrationResponseErrorConflictException(value: ConflictException)
  UpdateIntegrationResponseErrorLimitExceededException(
    value: LimitExceededException,
  )
  UpdateIntegrationResponseErrorNotFoundException(value: NotFoundException)
  UpdateIntegrationResponseErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  UpdateIntegrationResponseErrorUnauthorizedException(
    value: UnauthorizedException,
  )
  UpdateIntegrationResponseErrorTransport(reason: String)
  UpdateIntegrationResponseErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn update_integration_response_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(UpdateIntegrationResponseErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(UpdateIntegrationResponseErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) ->
          Ok(UpdateIntegrationResponseErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(UpdateIntegrationResponseErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) ->
          Ok(UpdateIntegrationResponseErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) ->
          Ok(UpdateIntegrationResponseErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_update_integration_response_error(
  err: runtime.ClientError,
) -> UpdateIntegrationResponseError {
  runtime.translate_service_error(
    err,
    update_integration_response_error_decoders(),
    fn(reason) { UpdateIntegrationResponseErrorTransport(reason: reason) },
    fn(et, s, body) {
      UpdateIntegrationResponseErrorUnknown(
        error_type: et,
        status: s,
        body: body,
      )
    },
  )
}

pub type UpdateMethodError {
  UpdateMethodErrorBadRequestException(value: BadRequestException)
  UpdateMethodErrorConflictException(value: ConflictException)
  UpdateMethodErrorNotFoundException(value: NotFoundException)
  UpdateMethodErrorTooManyRequestsException(value: TooManyRequestsException)
  UpdateMethodErrorUnauthorizedException(value: UnauthorizedException)
  UpdateMethodErrorTransport(reason: String)
  UpdateMethodErrorUnknown(error_type: String, status: Int, body: String)
}

fn update_method_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(UpdateMethodErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(UpdateMethodErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(UpdateMethodErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(UpdateMethodErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(UpdateMethodErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_update_method_error(
  err: runtime.ClientError,
) -> UpdateMethodError {
  runtime.translate_service_error(
    err,
    update_method_error_decoders(),
    fn(reason) { UpdateMethodErrorTransport(reason: reason) },
    fn(et, s, body) {
      UpdateMethodErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type UpdateMethodResponseError {
  UpdateMethodResponseErrorBadRequestException(value: BadRequestException)
  UpdateMethodResponseErrorConflictException(value: ConflictException)
  UpdateMethodResponseErrorLimitExceededException(value: LimitExceededException)
  UpdateMethodResponseErrorNotFoundException(value: NotFoundException)
  UpdateMethodResponseErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  UpdateMethodResponseErrorUnauthorizedException(value: UnauthorizedException)
  UpdateMethodResponseErrorTransport(reason: String)
  UpdateMethodResponseErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn update_method_response_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(UpdateMethodResponseErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(UpdateMethodResponseErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(UpdateMethodResponseErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(UpdateMethodResponseErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(UpdateMethodResponseErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(UpdateMethodResponseErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_update_method_response_error(
  err: runtime.ClientError,
) -> UpdateMethodResponseError {
  runtime.translate_service_error(
    err,
    update_method_response_error_decoders(),
    fn(reason) { UpdateMethodResponseErrorTransport(reason: reason) },
    fn(et, s, body) {
      UpdateMethodResponseErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type UpdateModelError {
  UpdateModelErrorBadRequestException(value: BadRequestException)
  UpdateModelErrorConflictException(value: ConflictException)
  UpdateModelErrorLimitExceededException(value: LimitExceededException)
  UpdateModelErrorNotFoundException(value: NotFoundException)
  UpdateModelErrorTooManyRequestsException(value: TooManyRequestsException)
  UpdateModelErrorUnauthorizedException(value: UnauthorizedException)
  UpdateModelErrorTransport(reason: String)
  UpdateModelErrorUnknown(error_type: String, status: Int, body: String)
}

fn update_model_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(UpdateModelErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(UpdateModelErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(UpdateModelErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(UpdateModelErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(UpdateModelErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(UpdateModelErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_update_model_error(err: runtime.ClientError) -> UpdateModelError {
  runtime.translate_service_error(
    err,
    update_model_error_decoders(),
    fn(reason) { UpdateModelErrorTransport(reason: reason) },
    fn(et, s, body) {
      UpdateModelErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type UpdateRequestValidatorError {
  UpdateRequestValidatorErrorBadRequestException(value: BadRequestException)
  UpdateRequestValidatorErrorConflictException(value: ConflictException)
  UpdateRequestValidatorErrorLimitExceededException(
    value: LimitExceededException,
  )
  UpdateRequestValidatorErrorNotFoundException(value: NotFoundException)
  UpdateRequestValidatorErrorTooManyRequestsException(
    value: TooManyRequestsException,
  )
  UpdateRequestValidatorErrorUnauthorizedException(value: UnauthorizedException)
  UpdateRequestValidatorErrorTransport(reason: String)
  UpdateRequestValidatorErrorUnknown(
    error_type: String,
    status: Int,
    body: String,
  )
}

fn update_request_validator_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(UpdateRequestValidatorErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(UpdateRequestValidatorErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(UpdateRequestValidatorErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(UpdateRequestValidatorErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) ->
          Ok(UpdateRequestValidatorErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(UpdateRequestValidatorErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_update_request_validator_error(
  err: runtime.ClientError,
) -> UpdateRequestValidatorError {
  runtime.translate_service_error(
    err,
    update_request_validator_error_decoders(),
    fn(reason) { UpdateRequestValidatorErrorTransport(reason: reason) },
    fn(et, s, body) {
      UpdateRequestValidatorErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type UpdateResourceError {
  UpdateResourceErrorBadRequestException(value: BadRequestException)
  UpdateResourceErrorConflictException(value: ConflictException)
  UpdateResourceErrorNotFoundException(value: NotFoundException)
  UpdateResourceErrorTooManyRequestsException(value: TooManyRequestsException)
  UpdateResourceErrorUnauthorizedException(value: UnauthorizedException)
  UpdateResourceErrorTransport(reason: String)
  UpdateResourceErrorUnknown(error_type: String, status: Int, body: String)
}

fn update_resource_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(UpdateResourceErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(UpdateResourceErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(UpdateResourceErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(UpdateResourceErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(UpdateResourceErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_update_resource_error(
  err: runtime.ClientError,
) -> UpdateResourceError {
  runtime.translate_service_error(
    err,
    update_resource_error_decoders(),
    fn(reason) { UpdateResourceErrorTransport(reason: reason) },
    fn(et, s, body) {
      UpdateResourceErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type UpdateRestApiError {
  UpdateRestApiErrorBadRequestException(value: BadRequestException)
  UpdateRestApiErrorConflictException(value: ConflictException)
  UpdateRestApiErrorLimitExceededException(value: LimitExceededException)
  UpdateRestApiErrorNotFoundException(value: NotFoundException)
  UpdateRestApiErrorTooManyRequestsException(value: TooManyRequestsException)
  UpdateRestApiErrorUnauthorizedException(value: UnauthorizedException)
  UpdateRestApiErrorTransport(reason: String)
  UpdateRestApiErrorUnknown(error_type: String, status: Int, body: String)
}

fn update_rest_api_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(UpdateRestApiErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(UpdateRestApiErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(UpdateRestApiErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(UpdateRestApiErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(UpdateRestApiErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(UpdateRestApiErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_update_rest_api_error(
  err: runtime.ClientError,
) -> UpdateRestApiError {
  runtime.translate_service_error(
    err,
    update_rest_api_error_decoders(),
    fn(reason) { UpdateRestApiErrorTransport(reason: reason) },
    fn(et, s, body) {
      UpdateRestApiErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type UpdateStageError {
  UpdateStageErrorBadRequestException(value: BadRequestException)
  UpdateStageErrorConflictException(value: ConflictException)
  UpdateStageErrorLimitExceededException(value: LimitExceededException)
  UpdateStageErrorNotFoundException(value: NotFoundException)
  UpdateStageErrorTooManyRequestsException(value: TooManyRequestsException)
  UpdateStageErrorUnauthorizedException(value: UnauthorizedException)
  UpdateStageErrorTransport(reason: String)
  UpdateStageErrorUnknown(error_type: String, status: Int, body: String)
}

fn update_stage_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(UpdateStageErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(UpdateStageErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(UpdateStageErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(UpdateStageErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(UpdateStageErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(UpdateStageErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_update_stage_error(err: runtime.ClientError) -> UpdateStageError {
  runtime.translate_service_error(
    err,
    update_stage_error_decoders(),
    fn(reason) { UpdateStageErrorTransport(reason: reason) },
    fn(et, s, body) {
      UpdateStageErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type UpdateUsageError {
  UpdateUsageErrorBadRequestException(value: BadRequestException)
  UpdateUsageErrorConflictException(value: ConflictException)
  UpdateUsageErrorLimitExceededException(value: LimitExceededException)
  UpdateUsageErrorNotFoundException(value: NotFoundException)
  UpdateUsageErrorTooManyRequestsException(value: TooManyRequestsException)
  UpdateUsageErrorUnauthorizedException(value: UnauthorizedException)
  UpdateUsageErrorTransport(reason: String)
  UpdateUsageErrorUnknown(error_type: String, status: Int, body: String)
}

fn update_usage_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(UpdateUsageErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(UpdateUsageErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(UpdateUsageErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(UpdateUsageErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(UpdateUsageErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(UpdateUsageErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_update_usage_error(err: runtime.ClientError) -> UpdateUsageError {
  runtime.translate_service_error(
    err,
    update_usage_error_decoders(),
    fn(reason) { UpdateUsageErrorTransport(reason: reason) },
    fn(et, s, body) {
      UpdateUsageErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type UpdateUsagePlanError {
  UpdateUsagePlanErrorBadRequestException(value: BadRequestException)
  UpdateUsagePlanErrorConflictException(value: ConflictException)
  UpdateUsagePlanErrorLimitExceededException(value: LimitExceededException)
  UpdateUsagePlanErrorNotFoundException(value: NotFoundException)
  UpdateUsagePlanErrorTooManyRequestsException(value: TooManyRequestsException)
  UpdateUsagePlanErrorUnauthorizedException(value: UnauthorizedException)
  UpdateUsagePlanErrorTransport(reason: String)
  UpdateUsagePlanErrorUnknown(error_type: String, status: Int, body: String)
}

fn update_usage_plan_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(UpdateUsagePlanErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(UpdateUsagePlanErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(UpdateUsagePlanErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(UpdateUsagePlanErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(UpdateUsagePlanErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(UpdateUsagePlanErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_update_usage_plan_error(
  err: runtime.ClientError,
) -> UpdateUsagePlanError {
  runtime.translate_service_error(
    err,
    update_usage_plan_error_decoders(),
    fn(reason) { UpdateUsagePlanErrorTransport(reason: reason) },
    fn(et, s, body) {
      UpdateUsagePlanErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub type UpdateVpcLinkError {
  UpdateVpcLinkErrorBadRequestException(value: BadRequestException)
  UpdateVpcLinkErrorConflictException(value: ConflictException)
  UpdateVpcLinkErrorLimitExceededException(value: LimitExceededException)
  UpdateVpcLinkErrorNotFoundException(value: NotFoundException)
  UpdateVpcLinkErrorTooManyRequestsException(value: TooManyRequestsException)
  UpdateVpcLinkErrorUnauthorizedException(value: UnauthorizedException)
  UpdateVpcLinkErrorTransport(reason: String)
  UpdateVpcLinkErrorUnknown(error_type: String, status: Int, body: String)
}

fn update_vpc_link_error_decoders() {
  [
    #("BadRequestException", fn(body) {
      case json.parse(body, decode_bad_request_exception_struct()) {
        Ok(v) -> Ok(UpdateVpcLinkErrorBadRequestException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("ConflictException", fn(body) {
      case json.parse(body, decode_conflict_exception_struct()) {
        Ok(v) -> Ok(UpdateVpcLinkErrorConflictException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("LimitExceededException", fn(body) {
      case json.parse(body, decode_limit_exceeded_exception_struct()) {
        Ok(v) -> Ok(UpdateVpcLinkErrorLimitExceededException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("NotFoundException", fn(body) {
      case json.parse(body, decode_not_found_exception_struct()) {
        Ok(v) -> Ok(UpdateVpcLinkErrorNotFoundException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("TooManyRequestsException", fn(body) {
      case json.parse(body, decode_too_many_requests_exception_struct()) {
        Ok(v) -> Ok(UpdateVpcLinkErrorTooManyRequestsException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
    #("UnauthorizedException", fn(body) {
      case json.parse(body, decode_unauthorized_exception_struct()) {
        Ok(v) -> Ok(UpdateVpcLinkErrorUnauthorizedException(value: v))
        Error(_) -> Error(Nil)
      }
    }),
  ]
}

fn translate_update_vpc_link_error(
  err: runtime.ClientError,
) -> UpdateVpcLinkError {
  runtime.translate_service_error(
    err,
    update_vpc_link_error_decoders(),
    fn(reason) { UpdateVpcLinkErrorTransport(reason: reason) },
    fn(et, s, body) {
      UpdateVpcLinkErrorUnknown(error_type: et, status: s, body: body)
    },
  )
}

pub fn parse_bad_request_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(headers, body, "BadRequestException")
}

pub fn parse_conflict_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(headers, body, "ConflictException")
}

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_not_found_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(headers, body, "NotFoundException")
}

pub fn parse_too_many_requests_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(headers, body, "TooManyRequestsException")
}

pub fn parse_unauthorized_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(headers, body, "UnauthorizedException")
}

pub fn parse_service_unavailable_exception_response(
  _code: Int,
  headers: dict.Dict(String, String),
  body: BitArray,
) -> Result(Nil, String) {
  runtime.check_error_type_matches(headers, body, "ServiceUnavailableException")
}

pub fn create_api_key(
  client: Client,
  input: CreateApiKeyRequest,
) -> Result(ApiKey, CreateApiKeyError) {
  case
    runtime.invoke(
      client.config,
      build_create_api_key_request(input),
      parse_create_api_key_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_create_api_key_error(err))
  }
}

pub fn create_authorizer(
  client: Client,
  input: CreateAuthorizerRequest,
) -> Result(Authorizer, CreateAuthorizerError) {
  case
    runtime.invoke(
      client.config,
      build_create_authorizer_request(input),
      parse_create_authorizer_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_create_authorizer_error(err))
  }
}

pub fn create_base_path_mapping(
  client: Client,
  input: CreateBasePathMappingRequest,
) -> Result(BasePathMapping, CreateBasePathMappingError) {
  case
    runtime.invoke(
      client.config,
      build_create_base_path_mapping_request(input),
      parse_create_base_path_mapping_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_create_base_path_mapping_error(err))
  }
}

pub fn create_deployment(
  client: Client,
  input: CreateDeploymentRequest,
) -> Result(Deployment, CreateDeploymentError) {
  case
    runtime.invoke(
      client.config,
      build_create_deployment_request(input),
      parse_create_deployment_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_create_deployment_error(err))
  }
}

pub fn create_documentation_part(
  client: Client,
  input: CreateDocumentationPartRequest,
) -> Result(DocumentationPart, CreateDocumentationPartError) {
  case
    runtime.invoke(
      client.config,
      build_create_documentation_part_request(input),
      parse_create_documentation_part_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_create_documentation_part_error(err))
  }
}

pub fn create_documentation_version(
  client: Client,
  input: CreateDocumentationVersionRequest,
) -> Result(DocumentationVersion, CreateDocumentationVersionError) {
  case
    runtime.invoke(
      client.config,
      build_create_documentation_version_request(input),
      parse_create_documentation_version_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_create_documentation_version_error(err))
  }
}

pub fn create_domain_name(
  client: Client,
  input: CreateDomainNameRequest,
) -> Result(DomainName, CreateDomainNameError) {
  case
    runtime.invoke(
      client.config,
      build_create_domain_name_request(input),
      parse_create_domain_name_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_create_domain_name_error(err))
  }
}

pub fn create_domain_name_access_association(
  client: Client,
  input: CreateDomainNameAccessAssociationRequest,
) -> Result(DomainNameAccessAssociation, CreateDomainNameAccessAssociationError) {
  case
    runtime.invoke(
      client.config,
      build_create_domain_name_access_association_request(input),
      parse_create_domain_name_access_association_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) ->
      Error(translate_create_domain_name_access_association_error(err))
  }
}

pub fn create_model(
  client: Client,
  input: CreateModelRequest,
) -> Result(Model, CreateModelError) {
  case
    runtime.invoke(
      client.config,
      build_create_model_request(input),
      parse_create_model_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_create_model_error(err))
  }
}

pub fn create_request_validator(
  client: Client,
  input: CreateRequestValidatorRequest,
) -> Result(RequestValidator, CreateRequestValidatorError) {
  case
    runtime.invoke(
      client.config,
      build_create_request_validator_request(input),
      parse_create_request_validator_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_create_request_validator_error(err))
  }
}

pub fn create_resource(
  client: Client,
  input: CreateResourceRequest,
) -> Result(Resource, CreateResourceError) {
  case
    runtime.invoke(
      client.config,
      build_create_resource_request(input),
      parse_create_resource_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_create_resource_error(err))
  }
}

pub fn create_rest_api(
  client: Client,
  input: CreateRestApiRequest,
) -> Result(RestApi, CreateRestApiError) {
  case
    runtime.invoke(
      client.config,
      build_create_rest_api_request(input),
      parse_create_rest_api_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_create_rest_api_error(err))
  }
}

pub fn create_stage(
  client: Client,
  input: CreateStageRequest,
) -> Result(Stage, CreateStageError) {
  case
    runtime.invoke(
      client.config,
      build_create_stage_request(input),
      parse_create_stage_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_create_stage_error(err))
  }
}

pub fn create_usage_plan(
  client: Client,
  input: CreateUsagePlanRequest,
) -> Result(UsagePlan, CreateUsagePlanError) {
  case
    runtime.invoke(
      client.config,
      build_create_usage_plan_request(input),
      parse_create_usage_plan_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_create_usage_plan_error(err))
  }
}

pub fn create_usage_plan_key(
  client: Client,
  input: CreateUsagePlanKeyRequest,
) -> Result(UsagePlanKey, CreateUsagePlanKeyError) {
  case
    runtime.invoke(
      client.config,
      build_create_usage_plan_key_request(input),
      parse_create_usage_plan_key_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_create_usage_plan_key_error(err))
  }
}

pub fn create_vpc_link(
  client: Client,
  input: CreateVpcLinkRequest,
) -> Result(VpcLink, CreateVpcLinkError) {
  case
    runtime.invoke(
      client.config,
      build_create_vpc_link_request(input),
      parse_create_vpc_link_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_create_vpc_link_error(err))
  }
}

pub fn delete_api_key(
  client: Client,
  input: DeleteApiKeyRequest,
) -> Result(DeleteApiKeyOutput, DeleteApiKeyError) {
  case
    runtime.invoke(
      client.config,
      build_delete_api_key_request(input),
      parse_delete_api_key_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_delete_api_key_error(err))
  }
}

pub fn delete_authorizer(
  client: Client,
  input: DeleteAuthorizerRequest,
) -> Result(DeleteAuthorizerOutput, DeleteAuthorizerError) {
  case
    runtime.invoke(
      client.config,
      build_delete_authorizer_request(input),
      parse_delete_authorizer_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_delete_authorizer_error(err))
  }
}

pub fn delete_base_path_mapping(
  client: Client,
  input: DeleteBasePathMappingRequest,
) -> Result(DeleteBasePathMappingOutput, DeleteBasePathMappingError) {
  case
    runtime.invoke(
      client.config,
      build_delete_base_path_mapping_request(input),
      parse_delete_base_path_mapping_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_delete_base_path_mapping_error(err))
  }
}

pub fn delete_client_certificate(
  client: Client,
  input: DeleteClientCertificateRequest,
) -> Result(DeleteClientCertificateOutput, DeleteClientCertificateError) {
  case
    runtime.invoke(
      client.config,
      build_delete_client_certificate_request(input),
      parse_delete_client_certificate_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_delete_client_certificate_error(err))
  }
}

pub fn delete_deployment(
  client: Client,
  input: DeleteDeploymentRequest,
) -> Result(DeleteDeploymentOutput, DeleteDeploymentError) {
  case
    runtime.invoke(
      client.config,
      build_delete_deployment_request(input),
      parse_delete_deployment_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_delete_deployment_error(err))
  }
}

pub fn delete_documentation_part(
  client: Client,
  input: DeleteDocumentationPartRequest,
) -> Result(DeleteDocumentationPartOutput, DeleteDocumentationPartError) {
  case
    runtime.invoke(
      client.config,
      build_delete_documentation_part_request(input),
      parse_delete_documentation_part_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_delete_documentation_part_error(err))
  }
}

pub fn delete_documentation_version(
  client: Client,
  input: DeleteDocumentationVersionRequest,
) -> Result(DeleteDocumentationVersionOutput, DeleteDocumentationVersionError) {
  case
    runtime.invoke(
      client.config,
      build_delete_documentation_version_request(input),
      parse_delete_documentation_version_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_delete_documentation_version_error(err))
  }
}

pub fn delete_domain_name(
  client: Client,
  input: DeleteDomainNameRequest,
) -> Result(DeleteDomainNameOutput, DeleteDomainNameError) {
  case
    runtime.invoke(
      client.config,
      build_delete_domain_name_request(input),
      parse_delete_domain_name_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_delete_domain_name_error(err))
  }
}

pub fn delete_domain_name_access_association(
  client: Client,
  input: DeleteDomainNameAccessAssociationRequest,
) -> Result(
  DeleteDomainNameAccessAssociationOutput,
  DeleteDomainNameAccessAssociationError,
) {
  case
    runtime.invoke(
      client.config,
      build_delete_domain_name_access_association_request(input),
      parse_delete_domain_name_access_association_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) ->
      Error(translate_delete_domain_name_access_association_error(err))
  }
}

pub fn delete_gateway_response(
  client: Client,
  input: DeleteGatewayResponseRequest,
) -> Result(DeleteGatewayResponseOutput, DeleteGatewayResponseError) {
  case
    runtime.invoke(
      client.config,
      build_delete_gateway_response_request(input),
      parse_delete_gateway_response_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_delete_gateway_response_error(err))
  }
}

pub fn delete_integration(
  client: Client,
  input: DeleteIntegrationRequest,
) -> Result(DeleteIntegrationOutput, DeleteIntegrationError) {
  case
    runtime.invoke(
      client.config,
      build_delete_integration_request(input),
      parse_delete_integration_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_delete_integration_error(err))
  }
}

pub fn delete_integration_response(
  client: Client,
  input: DeleteIntegrationResponseRequest,
) -> Result(DeleteIntegrationResponseOutput, DeleteIntegrationResponseError) {
  case
    runtime.invoke(
      client.config,
      build_delete_integration_response_request(input),
      parse_delete_integration_response_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_delete_integration_response_error(err))
  }
}

pub fn delete_method(
  client: Client,
  input: DeleteMethodRequest,
) -> Result(DeleteMethodOutput, DeleteMethodError) {
  case
    runtime.invoke(
      client.config,
      build_delete_method_request(input),
      parse_delete_method_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_delete_method_error(err))
  }
}

pub fn delete_method_response(
  client: Client,
  input: DeleteMethodResponseRequest,
) -> Result(DeleteMethodResponseOutput, DeleteMethodResponseError) {
  case
    runtime.invoke(
      client.config,
      build_delete_method_response_request(input),
      parse_delete_method_response_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_delete_method_response_error(err))
  }
}

pub fn delete_model(
  client: Client,
  input: DeleteModelRequest,
) -> Result(DeleteModelOutput, DeleteModelError) {
  case
    runtime.invoke(
      client.config,
      build_delete_model_request(input),
      parse_delete_model_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_delete_model_error(err))
  }
}

pub fn delete_request_validator(
  client: Client,
  input: DeleteRequestValidatorRequest,
) -> Result(DeleteRequestValidatorOutput, DeleteRequestValidatorError) {
  case
    runtime.invoke(
      client.config,
      build_delete_request_validator_request(input),
      parse_delete_request_validator_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_delete_request_validator_error(err))
  }
}

pub fn delete_resource(
  client: Client,
  input: DeleteResourceRequest,
) -> Result(DeleteResourceOutput, DeleteResourceError) {
  case
    runtime.invoke(
      client.config,
      build_delete_resource_request(input),
      parse_delete_resource_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_delete_resource_error(err))
  }
}

pub fn delete_rest_api(
  client: Client,
  input: DeleteRestApiRequest,
) -> Result(DeleteRestApiOutput, DeleteRestApiError) {
  case
    runtime.invoke(
      client.config,
      build_delete_rest_api_request(input),
      parse_delete_rest_api_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_delete_rest_api_error(err))
  }
}

pub fn delete_stage(
  client: Client,
  input: DeleteStageRequest,
) -> Result(DeleteStageOutput, DeleteStageError) {
  case
    runtime.invoke(
      client.config,
      build_delete_stage_request(input),
      parse_delete_stage_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_delete_stage_error(err))
  }
}

pub fn delete_usage_plan(
  client: Client,
  input: DeleteUsagePlanRequest,
) -> Result(DeleteUsagePlanOutput, DeleteUsagePlanError) {
  case
    runtime.invoke(
      client.config,
      build_delete_usage_plan_request(input),
      parse_delete_usage_plan_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_delete_usage_plan_error(err))
  }
}

pub fn delete_usage_plan_key(
  client: Client,
  input: DeleteUsagePlanKeyRequest,
) -> Result(DeleteUsagePlanKeyOutput, DeleteUsagePlanKeyError) {
  case
    runtime.invoke(
      client.config,
      build_delete_usage_plan_key_request(input),
      parse_delete_usage_plan_key_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_delete_usage_plan_key_error(err))
  }
}

pub fn delete_vpc_link(
  client: Client,
  input: DeleteVpcLinkRequest,
) -> Result(DeleteVpcLinkOutput, DeleteVpcLinkError) {
  case
    runtime.invoke(
      client.config,
      build_delete_vpc_link_request(input),
      parse_delete_vpc_link_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_delete_vpc_link_error(err))
  }
}

pub fn flush_stage_authorizers_cache(
  client: Client,
  input: FlushStageAuthorizersCacheRequest,
) -> Result(FlushStageAuthorizersCacheOutput, FlushStageAuthorizersCacheError) {
  case
    runtime.invoke(
      client.config,
      build_flush_stage_authorizers_cache_request(input),
      parse_flush_stage_authorizers_cache_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_flush_stage_authorizers_cache_error(err))
  }
}

pub fn flush_stage_cache(
  client: Client,
  input: FlushStageCacheRequest,
) -> Result(FlushStageCacheOutput, FlushStageCacheError) {
  case
    runtime.invoke(
      client.config,
      build_flush_stage_cache_request(input),
      parse_flush_stage_cache_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_flush_stage_cache_error(err))
  }
}

pub fn generate_client_certificate(
  client: Client,
  input: GenerateClientCertificateRequest,
) -> Result(ClientCertificate, GenerateClientCertificateError) {
  case
    runtime.invoke(
      client.config,
      build_generate_client_certificate_request(input),
      parse_generate_client_certificate_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_generate_client_certificate_error(err))
  }
}

pub fn get_account(
  client: Client,
  input: GetAccountRequest,
) -> Result(Account, GetAccountError) {
  case
    runtime.invoke(
      client.config,
      build_get_account_request(input),
      parse_get_account_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_account_error(err))
  }
}

pub fn get_api_key(
  client: Client,
  input: GetApiKeyRequest,
) -> Result(ApiKey, GetApiKeyError) {
  case
    runtime.invoke(
      client.config,
      build_get_api_key_request(input),
      parse_get_api_key_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_api_key_error(err))
  }
}

pub fn get_api_keys(
  client: Client,
  input: GetApiKeysRequest,
) -> Result(ApiKeys, GetApiKeysError) {
  case
    runtime.invoke(
      client.config,
      build_get_api_keys_request(input),
      parse_get_api_keys_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_api_keys_error(err))
  }
}

pub fn get_authorizer(
  client: Client,
  input: GetAuthorizerRequest,
) -> Result(Authorizer, GetAuthorizerError) {
  case
    runtime.invoke(
      client.config,
      build_get_authorizer_request(input),
      parse_get_authorizer_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_authorizer_error(err))
  }
}

pub fn get_authorizers(
  client: Client,
  input: GetAuthorizersRequest,
) -> Result(Authorizers, GetAuthorizersError) {
  case
    runtime.invoke(
      client.config,
      build_get_authorizers_request(input),
      parse_get_authorizers_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_authorizers_error(err))
  }
}

pub fn get_base_path_mapping(
  client: Client,
  input: GetBasePathMappingRequest,
) -> Result(BasePathMapping, GetBasePathMappingError) {
  case
    runtime.invoke(
      client.config,
      build_get_base_path_mapping_request(input),
      parse_get_base_path_mapping_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_base_path_mapping_error(err))
  }
}

pub fn get_base_path_mappings(
  client: Client,
  input: GetBasePathMappingsRequest,
) -> Result(BasePathMappings, GetBasePathMappingsError) {
  case
    runtime.invoke(
      client.config,
      build_get_base_path_mappings_request(input),
      parse_get_base_path_mappings_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_base_path_mappings_error(err))
  }
}

pub fn get_client_certificate(
  client: Client,
  input: GetClientCertificateRequest,
) -> Result(ClientCertificate, GetClientCertificateError) {
  case
    runtime.invoke(
      client.config,
      build_get_client_certificate_request(input),
      parse_get_client_certificate_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_client_certificate_error(err))
  }
}

pub fn get_client_certificates(
  client: Client,
  input: GetClientCertificatesRequest,
) -> Result(ClientCertificates, GetClientCertificatesError) {
  case
    runtime.invoke(
      client.config,
      build_get_client_certificates_request(input),
      parse_get_client_certificates_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_client_certificates_error(err))
  }
}

pub fn get_deployment(
  client: Client,
  input: GetDeploymentRequest,
) -> Result(Deployment, GetDeploymentError) {
  case
    runtime.invoke(
      client.config,
      build_get_deployment_request(input),
      parse_get_deployment_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_deployment_error(err))
  }
}

pub fn get_deployments(
  client: Client,
  input: GetDeploymentsRequest,
) -> Result(Deployments, GetDeploymentsError) {
  case
    runtime.invoke(
      client.config,
      build_get_deployments_request(input),
      parse_get_deployments_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_deployments_error(err))
  }
}

pub fn get_documentation_part(
  client: Client,
  input: GetDocumentationPartRequest,
) -> Result(DocumentationPart, GetDocumentationPartError) {
  case
    runtime.invoke(
      client.config,
      build_get_documentation_part_request(input),
      parse_get_documentation_part_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_documentation_part_error(err))
  }
}

pub fn get_documentation_parts(
  client: Client,
  input: GetDocumentationPartsRequest,
) -> Result(DocumentationParts, GetDocumentationPartsError) {
  case
    runtime.invoke(
      client.config,
      build_get_documentation_parts_request(input),
      parse_get_documentation_parts_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_documentation_parts_error(err))
  }
}

pub fn get_documentation_version(
  client: Client,
  input: GetDocumentationVersionRequest,
) -> Result(DocumentationVersion, GetDocumentationVersionError) {
  case
    runtime.invoke(
      client.config,
      build_get_documentation_version_request(input),
      parse_get_documentation_version_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_documentation_version_error(err))
  }
}

pub fn get_documentation_versions(
  client: Client,
  input: GetDocumentationVersionsRequest,
) -> Result(DocumentationVersions, GetDocumentationVersionsError) {
  case
    runtime.invoke(
      client.config,
      build_get_documentation_versions_request(input),
      parse_get_documentation_versions_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_documentation_versions_error(err))
  }
}

pub fn get_domain_name(
  client: Client,
  input: GetDomainNameRequest,
) -> Result(DomainName, GetDomainNameError) {
  case
    runtime.invoke(
      client.config,
      build_get_domain_name_request(input),
      parse_get_domain_name_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_domain_name_error(err))
  }
}

pub fn get_domain_name_access_associations(
  client: Client,
  input: GetDomainNameAccessAssociationsRequest,
) -> Result(DomainNameAccessAssociations, GetDomainNameAccessAssociationsError) {
  case
    runtime.invoke(
      client.config,
      build_get_domain_name_access_associations_request(input),
      parse_get_domain_name_access_associations_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) ->
      Error(translate_get_domain_name_access_associations_error(err))
  }
}

pub fn get_domain_names(
  client: Client,
  input: GetDomainNamesRequest,
) -> Result(DomainNames, GetDomainNamesError) {
  case
    runtime.invoke(
      client.config,
      build_get_domain_names_request(input),
      parse_get_domain_names_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_domain_names_error(err))
  }
}

pub fn get_export(
  client: Client,
  input: GetExportRequest,
) -> Result(ExportResponse, GetExportError) {
  case
    runtime.invoke(
      client.config,
      build_get_export_request(input),
      parse_get_export_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_export_error(err))
  }
}

pub fn get_gateway_response(
  client: Client,
  input: GetGatewayResponseRequest,
) -> Result(GatewayResponse, GetGatewayResponseError) {
  case
    runtime.invoke(
      client.config,
      build_get_gateway_response_request(input),
      parse_get_gateway_response_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_gateway_response_error(err))
  }
}

pub fn get_gateway_responses(
  client: Client,
  input: GetGatewayResponsesRequest,
) -> Result(GatewayResponses, GetGatewayResponsesError) {
  case
    runtime.invoke(
      client.config,
      build_get_gateway_responses_request(input),
      parse_get_gateway_responses_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_gateway_responses_error(err))
  }
}

pub fn get_integration(
  client: Client,
  input: GetIntegrationRequest,
) -> Result(Integration, GetIntegrationError) {
  case
    runtime.invoke(
      client.config,
      build_get_integration_request(input),
      parse_get_integration_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_integration_error(err))
  }
}

pub fn get_integration_response(
  client: Client,
  input: GetIntegrationResponseRequest,
) -> Result(IntegrationResponse, GetIntegrationResponseError) {
  case
    runtime.invoke(
      client.config,
      build_get_integration_response_request(input),
      parse_get_integration_response_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_integration_response_error(err))
  }
}

pub fn get_method(
  client: Client,
  input: GetMethodRequest,
) -> Result(Method, GetMethodError) {
  case
    runtime.invoke(
      client.config,
      build_get_method_request(input),
      parse_get_method_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_method_error(err))
  }
}

pub fn get_method_response(
  client: Client,
  input: GetMethodResponseRequest,
) -> Result(MethodResponse, GetMethodResponseError) {
  case
    runtime.invoke(
      client.config,
      build_get_method_response_request(input),
      parse_get_method_response_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_method_response_error(err))
  }
}

pub fn get_model(
  client: Client,
  input: GetModelRequest,
) -> Result(Model, GetModelError) {
  case
    runtime.invoke(
      client.config,
      build_get_model_request(input),
      parse_get_model_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_model_error(err))
  }
}

pub fn get_models(
  client: Client,
  input: GetModelsRequest,
) -> Result(Models, GetModelsError) {
  case
    runtime.invoke(
      client.config,
      build_get_models_request(input),
      parse_get_models_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_models_error(err))
  }
}

pub fn get_model_template(
  client: Client,
  input: GetModelTemplateRequest,
) -> Result(Template, GetModelTemplateError) {
  case
    runtime.invoke(
      client.config,
      build_get_model_template_request(input),
      parse_get_model_template_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_model_template_error(err))
  }
}

pub fn get_request_validator(
  client: Client,
  input: GetRequestValidatorRequest,
) -> Result(RequestValidator, GetRequestValidatorError) {
  case
    runtime.invoke(
      client.config,
      build_get_request_validator_request(input),
      parse_get_request_validator_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_request_validator_error(err))
  }
}

pub fn get_request_validators(
  client: Client,
  input: GetRequestValidatorsRequest,
) -> Result(RequestValidators, GetRequestValidatorsError) {
  case
    runtime.invoke(
      client.config,
      build_get_request_validators_request(input),
      parse_get_request_validators_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_request_validators_error(err))
  }
}

pub fn get_resource(
  client: Client,
  input: GetResourceRequest,
) -> Result(Resource, GetResourceError) {
  case
    runtime.invoke(
      client.config,
      build_get_resource_request(input),
      parse_get_resource_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_resource_error(err))
  }
}

pub fn get_resources(
  client: Client,
  input: GetResourcesRequest,
) -> Result(Resources, GetResourcesError) {
  case
    runtime.invoke(
      client.config,
      build_get_resources_request(input),
      parse_get_resources_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_resources_error(err))
  }
}

pub fn get_rest_api(
  client: Client,
  input: GetRestApiRequest,
) -> Result(RestApi, GetRestApiError) {
  case
    runtime.invoke(
      client.config,
      build_get_rest_api_request(input),
      parse_get_rest_api_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_rest_api_error(err))
  }
}

pub fn get_rest_apis(
  client: Client,
  input: GetRestApisRequest,
) -> Result(RestApis, GetRestApisError) {
  case
    runtime.invoke(
      client.config,
      build_get_rest_apis_request(input),
      parse_get_rest_apis_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_rest_apis_error(err))
  }
}

pub fn get_sdk(
  client: Client,
  input: GetSdkRequest,
) -> Result(SdkResponse, GetSdkError) {
  case
    runtime.invoke(
      client.config,
      build_get_sdk_request(input),
      parse_get_sdk_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_sdk_error(err))
  }
}

pub fn get_sdk_type(
  client: Client,
  input: GetSdkTypeRequest,
) -> Result(SdkType, GetSdkTypeError) {
  case
    runtime.invoke(
      client.config,
      build_get_sdk_type_request(input),
      parse_get_sdk_type_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_sdk_type_error(err))
  }
}

pub fn get_sdk_types(
  client: Client,
  input: GetSdkTypesRequest,
) -> Result(SdkTypes, GetSdkTypesError) {
  case
    runtime.invoke(
      client.config,
      build_get_sdk_types_request(input),
      parse_get_sdk_types_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_sdk_types_error(err))
  }
}

pub fn get_stage(
  client: Client,
  input: GetStageRequest,
) -> Result(Stage, GetStageError) {
  case
    runtime.invoke(
      client.config,
      build_get_stage_request(input),
      parse_get_stage_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_stage_error(err))
  }
}

pub fn get_stages(
  client: Client,
  input: GetStagesRequest,
) -> Result(Stages, GetStagesError) {
  case
    runtime.invoke(
      client.config,
      build_get_stages_request(input),
      parse_get_stages_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_stages_error(err))
  }
}

pub fn get_tags(
  client: Client,
  input: GetTagsRequest,
) -> Result(Tags, GetTagsError) {
  case
    runtime.invoke(
      client.config,
      build_get_tags_request(input),
      parse_get_tags_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_tags_error(err))
  }
}

pub fn get_usage(
  client: Client,
  input: GetUsageRequest,
) -> Result(Usage, GetUsageError) {
  case
    runtime.invoke(
      client.config,
      build_get_usage_request(input),
      parse_get_usage_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_usage_error(err))
  }
}

pub fn get_usage_plan(
  client: Client,
  input: GetUsagePlanRequest,
) -> Result(UsagePlan, GetUsagePlanError) {
  case
    runtime.invoke(
      client.config,
      build_get_usage_plan_request(input),
      parse_get_usage_plan_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_usage_plan_error(err))
  }
}

pub fn get_usage_plan_key(
  client: Client,
  input: GetUsagePlanKeyRequest,
) -> Result(UsagePlanKey, GetUsagePlanKeyError) {
  case
    runtime.invoke(
      client.config,
      build_get_usage_plan_key_request(input),
      parse_get_usage_plan_key_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_usage_plan_key_error(err))
  }
}

pub fn get_usage_plan_keys(
  client: Client,
  input: GetUsagePlanKeysRequest,
) -> Result(UsagePlanKeys, GetUsagePlanKeysError) {
  case
    runtime.invoke(
      client.config,
      build_get_usage_plan_keys_request(input),
      parse_get_usage_plan_keys_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_usage_plan_keys_error(err))
  }
}

pub fn get_usage_plans(
  client: Client,
  input: GetUsagePlansRequest,
) -> Result(UsagePlans, GetUsagePlansError) {
  case
    runtime.invoke(
      client.config,
      build_get_usage_plans_request(input),
      parse_get_usage_plans_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_usage_plans_error(err))
  }
}

pub fn get_vpc_link(
  client: Client,
  input: GetVpcLinkRequest,
) -> Result(VpcLink, GetVpcLinkError) {
  case
    runtime.invoke(
      client.config,
      build_get_vpc_link_request(input),
      parse_get_vpc_link_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_vpc_link_error(err))
  }
}

pub fn get_vpc_links(
  client: Client,
  input: GetVpcLinksRequest,
) -> Result(VpcLinks, GetVpcLinksError) {
  case
    runtime.invoke(
      client.config,
      build_get_vpc_links_request(input),
      parse_get_vpc_links_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_get_vpc_links_error(err))
  }
}

pub fn import_api_keys(
  client: Client,
  input: ImportApiKeysRequest,
) -> Result(ApiKeyIds, ImportApiKeysError) {
  case
    runtime.invoke(
      client.config,
      build_import_api_keys_request(input),
      parse_import_api_keys_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_import_api_keys_error(err))
  }
}

pub fn import_documentation_parts(
  client: Client,
  input: ImportDocumentationPartsRequest,
) -> Result(DocumentationPartIds, ImportDocumentationPartsError) {
  case
    runtime.invoke(
      client.config,
      build_import_documentation_parts_request(input),
      parse_import_documentation_parts_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_import_documentation_parts_error(err))
  }
}

pub fn import_rest_api(
  client: Client,
  input: ImportRestApiRequest,
) -> Result(RestApi, ImportRestApiError) {
  case
    runtime.invoke(
      client.config,
      build_import_rest_api_request(input),
      parse_import_rest_api_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_import_rest_api_error(err))
  }
}

pub fn put_gateway_response(
  client: Client,
  input: PutGatewayResponseRequest,
) -> Result(GatewayResponse, PutGatewayResponseError) {
  case
    runtime.invoke(
      client.config,
      build_put_gateway_response_request(input),
      parse_put_gateway_response_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_put_gateway_response_error(err))
  }
}

pub fn put_integration(
  client: Client,
  input: PutIntegrationRequest,
) -> Result(Integration, PutIntegrationError) {
  case
    runtime.invoke(
      client.config,
      build_put_integration_request(input),
      parse_put_integration_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_put_integration_error(err))
  }
}

pub fn put_integration_response(
  client: Client,
  input: PutIntegrationResponseRequest,
) -> Result(IntegrationResponse, PutIntegrationResponseError) {
  case
    runtime.invoke(
      client.config,
      build_put_integration_response_request(input),
      parse_put_integration_response_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_put_integration_response_error(err))
  }
}

pub fn put_method(
  client: Client,
  input: PutMethodRequest,
) -> Result(Method, PutMethodError) {
  case
    runtime.invoke(
      client.config,
      build_put_method_request(input),
      parse_put_method_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_put_method_error(err))
  }
}

pub fn put_method_response(
  client: Client,
  input: PutMethodResponseRequest,
) -> Result(MethodResponse, PutMethodResponseError) {
  case
    runtime.invoke(
      client.config,
      build_put_method_response_request(input),
      parse_put_method_response_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_put_method_response_error(err))
  }
}

pub fn put_rest_api(
  client: Client,
  input: PutRestApiRequest,
) -> Result(RestApi, PutRestApiError) {
  case
    runtime.invoke(
      client.config,
      build_put_rest_api_request(input),
      parse_put_rest_api_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_put_rest_api_error(err))
  }
}

pub fn reject_domain_name_access_association(
  client: Client,
  input: RejectDomainNameAccessAssociationRequest,
) -> Result(
  RejectDomainNameAccessAssociationOutput,
  RejectDomainNameAccessAssociationError,
) {
  case
    runtime.invoke(
      client.config,
      build_reject_domain_name_access_association_request(input),
      parse_reject_domain_name_access_association_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) ->
      Error(translate_reject_domain_name_access_association_error(err))
  }
}

pub fn tag_resource(
  client: Client,
  input: TagResourceRequest,
) -> Result(TagResourceOutput, TagResourceError) {
  case
    runtime.invoke(
      client.config,
      build_tag_resource_request(input),
      parse_tag_resource_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_tag_resource_error(err))
  }
}

pub fn test_invoke_authorizer(
  client: Client,
  input: TestInvokeAuthorizerRequest,
) -> Result(TestInvokeAuthorizerResponse, TestInvokeAuthorizerError) {
  case
    runtime.invoke(
      client.config,
      build_test_invoke_authorizer_request(input),
      parse_test_invoke_authorizer_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_test_invoke_authorizer_error(err))
  }
}

pub fn test_invoke_method(
  client: Client,
  input: TestInvokeMethodRequest,
) -> Result(TestInvokeMethodResponse, TestInvokeMethodError) {
  case
    runtime.invoke(
      client.config,
      build_test_invoke_method_request(input),
      parse_test_invoke_method_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_test_invoke_method_error(err))
  }
}

pub fn untag_resource(
  client: Client,
  input: UntagResourceRequest,
) -> Result(UntagResourceOutput, UntagResourceError) {
  case
    runtime.invoke(
      client.config,
      build_untag_resource_request(input),
      parse_untag_resource_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_untag_resource_error(err))
  }
}

pub fn update_account(
  client: Client,
  input: UpdateAccountRequest,
) -> Result(Account, UpdateAccountError) {
  case
    runtime.invoke(
      client.config,
      build_update_account_request(input),
      parse_update_account_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_update_account_error(err))
  }
}

pub fn update_api_key(
  client: Client,
  input: UpdateApiKeyRequest,
) -> Result(ApiKey, UpdateApiKeyError) {
  case
    runtime.invoke(
      client.config,
      build_update_api_key_request(input),
      parse_update_api_key_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_update_api_key_error(err))
  }
}

pub fn update_authorizer(
  client: Client,
  input: UpdateAuthorizerRequest,
) -> Result(Authorizer, UpdateAuthorizerError) {
  case
    runtime.invoke(
      client.config,
      build_update_authorizer_request(input),
      parse_update_authorizer_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_update_authorizer_error(err))
  }
}

pub fn update_base_path_mapping(
  client: Client,
  input: UpdateBasePathMappingRequest,
) -> Result(BasePathMapping, UpdateBasePathMappingError) {
  case
    runtime.invoke(
      client.config,
      build_update_base_path_mapping_request(input),
      parse_update_base_path_mapping_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_update_base_path_mapping_error(err))
  }
}

pub fn update_client_certificate(
  client: Client,
  input: UpdateClientCertificateRequest,
) -> Result(ClientCertificate, UpdateClientCertificateError) {
  case
    runtime.invoke(
      client.config,
      build_update_client_certificate_request(input),
      parse_update_client_certificate_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_update_client_certificate_error(err))
  }
}

pub fn update_deployment(
  client: Client,
  input: UpdateDeploymentRequest,
) -> Result(Deployment, UpdateDeploymentError) {
  case
    runtime.invoke(
      client.config,
      build_update_deployment_request(input),
      parse_update_deployment_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_update_deployment_error(err))
  }
}

pub fn update_documentation_part(
  client: Client,
  input: UpdateDocumentationPartRequest,
) -> Result(DocumentationPart, UpdateDocumentationPartError) {
  case
    runtime.invoke(
      client.config,
      build_update_documentation_part_request(input),
      parse_update_documentation_part_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_update_documentation_part_error(err))
  }
}

pub fn update_documentation_version(
  client: Client,
  input: UpdateDocumentationVersionRequest,
) -> Result(DocumentationVersion, UpdateDocumentationVersionError) {
  case
    runtime.invoke(
      client.config,
      build_update_documentation_version_request(input),
      parse_update_documentation_version_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_update_documentation_version_error(err))
  }
}

pub fn update_domain_name(
  client: Client,
  input: UpdateDomainNameRequest,
) -> Result(DomainName, UpdateDomainNameError) {
  case
    runtime.invoke(
      client.config,
      build_update_domain_name_request(input),
      parse_update_domain_name_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_update_domain_name_error(err))
  }
}

pub fn update_gateway_response(
  client: Client,
  input: UpdateGatewayResponseRequest,
) -> Result(GatewayResponse, UpdateGatewayResponseError) {
  case
    runtime.invoke(
      client.config,
      build_update_gateway_response_request(input),
      parse_update_gateway_response_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_update_gateway_response_error(err))
  }
}

pub fn update_integration(
  client: Client,
  input: UpdateIntegrationRequest,
) -> Result(Integration, UpdateIntegrationError) {
  case
    runtime.invoke(
      client.config,
      build_update_integration_request(input),
      parse_update_integration_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_update_integration_error(err))
  }
}

pub fn update_integration_response(
  client: Client,
  input: UpdateIntegrationResponseRequest,
) -> Result(IntegrationResponse, UpdateIntegrationResponseError) {
  case
    runtime.invoke(
      client.config,
      build_update_integration_response_request(input),
      parse_update_integration_response_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_update_integration_response_error(err))
  }
}

pub fn update_method(
  client: Client,
  input: UpdateMethodRequest,
) -> Result(Method, UpdateMethodError) {
  case
    runtime.invoke(
      client.config,
      build_update_method_request(input),
      parse_update_method_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_update_method_error(err))
  }
}

pub fn update_method_response(
  client: Client,
  input: UpdateMethodResponseRequest,
) -> Result(MethodResponse, UpdateMethodResponseError) {
  case
    runtime.invoke(
      client.config,
      build_update_method_response_request(input),
      parse_update_method_response_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_update_method_response_error(err))
  }
}

pub fn update_model(
  client: Client,
  input: UpdateModelRequest,
) -> Result(Model, UpdateModelError) {
  case
    runtime.invoke(
      client.config,
      build_update_model_request(input),
      parse_update_model_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_update_model_error(err))
  }
}

pub fn update_request_validator(
  client: Client,
  input: UpdateRequestValidatorRequest,
) -> Result(RequestValidator, UpdateRequestValidatorError) {
  case
    runtime.invoke(
      client.config,
      build_update_request_validator_request(input),
      parse_update_request_validator_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_update_request_validator_error(err))
  }
}

pub fn update_resource(
  client: Client,
  input: UpdateResourceRequest,
) -> Result(Resource, UpdateResourceError) {
  case
    runtime.invoke(
      client.config,
      build_update_resource_request(input),
      parse_update_resource_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_update_resource_error(err))
  }
}

pub fn update_rest_api(
  client: Client,
  input: UpdateRestApiRequest,
) -> Result(RestApi, UpdateRestApiError) {
  case
    runtime.invoke(
      client.config,
      build_update_rest_api_request(input),
      parse_update_rest_api_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_update_rest_api_error(err))
  }
}

pub fn update_stage(
  client: Client,
  input: UpdateStageRequest,
) -> Result(Stage, UpdateStageError) {
  case
    runtime.invoke(
      client.config,
      build_update_stage_request(input),
      parse_update_stage_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_update_stage_error(err))
  }
}

pub fn update_usage(
  client: Client,
  input: UpdateUsageRequest,
) -> Result(Usage, UpdateUsageError) {
  case
    runtime.invoke(
      client.config,
      build_update_usage_request(input),
      parse_update_usage_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_update_usage_error(err))
  }
}

pub fn update_usage_plan(
  client: Client,
  input: UpdateUsagePlanRequest,
) -> Result(UsagePlan, UpdateUsagePlanError) {
  case
    runtime.invoke(
      client.config,
      build_update_usage_plan_request(input),
      parse_update_usage_plan_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_update_usage_plan_error(err))
  }
}

pub fn update_vpc_link(
  client: Client,
  input: UpdateVpcLinkRequest,
) -> Result(VpcLink, UpdateVpcLinkError) {
  case
    runtime.invoke(
      client.config,
      build_update_vpc_link_request(input),
      parse_update_vpc_link_response,
    )
  {
    Ok(out) -> Ok(out)
    Error(err) -> Error(translate_update_vpc_link_error(err))
  }
}

pub fn paginate_get_api_keys(
  client: Client,
  input: GetApiKeysRequest,
  acc: acc,
  reducer: fn(acc, List(ApiKey)) -> acc,
) -> Result(acc, GetApiKeysError) {
  let step = fn(cursor) {
    {
      let input = case cursor {
        option.Some(_) -> GetApiKeysRequest(..input, position: cursor)
        option.None -> input
      }
      case get_api_keys(client, input) {
        Ok(out) -> Ok(#(option.unwrap(out.items, []), out.position))
        Error(e) -> Error(e)
      }
    }
  }
  pagination.fold(acc: acc, step: step, reducer: reducer)
}

pub fn paginate_get_base_path_mappings(
  client: Client,
  input: GetBasePathMappingsRequest,
  acc: acc,
  reducer: fn(acc, List(BasePathMapping)) -> acc,
) -> Result(acc, GetBasePathMappingsError) {
  let step = fn(cursor) {
    {
      let input = case cursor {
        option.Some(_) -> GetBasePathMappingsRequest(..input, position: cursor)
        option.None -> input
      }
      case get_base_path_mappings(client, input) {
        Ok(out) -> Ok(#(option.unwrap(out.items, []), out.position))
        Error(e) -> Error(e)
      }
    }
  }
  pagination.fold(acc: acc, step: step, reducer: reducer)
}

pub fn paginate_get_client_certificates(
  client: Client,
  input: GetClientCertificatesRequest,
  acc: acc,
  reducer: fn(acc, List(ClientCertificate)) -> acc,
) -> Result(acc, GetClientCertificatesError) {
  let step = fn(cursor) {
    {
      let input = case cursor {
        option.Some(_) ->
          GetClientCertificatesRequest(..input, position: cursor)
        option.None -> input
      }
      case get_client_certificates(client, input) {
        Ok(out) -> Ok(#(option.unwrap(out.items, []), out.position))
        Error(e) -> Error(e)
      }
    }
  }
  pagination.fold(acc: acc, step: step, reducer: reducer)
}

pub fn paginate_get_deployments(
  client: Client,
  input: GetDeploymentsRequest,
  acc: acc,
  reducer: fn(acc, List(Deployment)) -> acc,
) -> Result(acc, GetDeploymentsError) {
  let step = fn(cursor) {
    {
      let input = case cursor {
        option.Some(_) -> GetDeploymentsRequest(..input, position: cursor)
        option.None -> input
      }
      case get_deployments(client, input) {
        Ok(out) -> Ok(#(option.unwrap(out.items, []), out.position))
        Error(e) -> Error(e)
      }
    }
  }
  pagination.fold(acc: acc, step: step, reducer: reducer)
}

pub fn paginate_get_domain_names(
  client: Client,
  input: GetDomainNamesRequest,
  acc: acc,
  reducer: fn(acc, List(DomainName)) -> acc,
) -> Result(acc, GetDomainNamesError) {
  let step = fn(cursor) {
    {
      let input = case cursor {
        option.Some(_) -> GetDomainNamesRequest(..input, position: cursor)
        option.None -> input
      }
      case get_domain_names(client, input) {
        Ok(out) -> Ok(#(option.unwrap(out.items, []), out.position))
        Error(e) -> Error(e)
      }
    }
  }
  pagination.fold(acc: acc, step: step, reducer: reducer)
}

pub fn paginate_get_models(
  client: Client,
  input: GetModelsRequest,
  acc: acc,
  reducer: fn(acc, List(Model)) -> acc,
) -> Result(acc, GetModelsError) {
  let step = fn(cursor) {
    {
      let input = case cursor {
        option.Some(_) -> GetModelsRequest(..input, position: cursor)
        option.None -> input
      }
      case get_models(client, input) {
        Ok(out) -> Ok(#(option.unwrap(out.items, []), out.position))
        Error(e) -> Error(e)
      }
    }
  }
  pagination.fold(acc: acc, step: step, reducer: reducer)
}

pub fn paginate_get_resources(
  client: Client,
  input: GetResourcesRequest,
  acc: acc,
  reducer: fn(acc, List(Resource)) -> acc,
) -> Result(acc, GetResourcesError) {
  let step = fn(cursor) {
    {
      let input = case cursor {
        option.Some(_) -> GetResourcesRequest(..input, position: cursor)
        option.None -> input
      }
      case get_resources(client, input) {
        Ok(out) -> Ok(#(option.unwrap(out.items, []), out.position))
        Error(e) -> Error(e)
      }
    }
  }
  pagination.fold(acc: acc, step: step, reducer: reducer)
}

pub fn paginate_get_rest_apis(
  client: Client,
  input: GetRestApisRequest,
  acc: acc,
  reducer: fn(acc, List(RestApi)) -> acc,
) -> Result(acc, GetRestApisError) {
  let step = fn(cursor) {
    {
      let input = case cursor {
        option.Some(_) -> GetRestApisRequest(..input, position: cursor)
        option.None -> input
      }
      case get_rest_apis(client, input) {
        Ok(out) -> Ok(#(option.unwrap(out.items, []), out.position))
        Error(e) -> Error(e)
      }
    }
  }
  pagination.fold(acc: acc, step: step, reducer: reducer)
}

pub fn paginate_get_usage_plan_keys(
  client: Client,
  input: GetUsagePlanKeysRequest,
  acc: acc,
  reducer: fn(acc, List(UsagePlanKey)) -> acc,
) -> Result(acc, GetUsagePlanKeysError) {
  let step = fn(cursor) {
    {
      let input = case cursor {
        option.Some(_) -> GetUsagePlanKeysRequest(..input, position: cursor)
        option.None -> input
      }
      case get_usage_plan_keys(client, input) {
        Ok(out) -> Ok(#(option.unwrap(out.items, []), out.position))
        Error(e) -> Error(e)
      }
    }
  }
  pagination.fold(acc: acc, step: step, reducer: reducer)
}

pub fn paginate_get_usage_plans(
  client: Client,
  input: GetUsagePlansRequest,
  acc: acc,
  reducer: fn(acc, List(UsagePlan)) -> acc,
) -> Result(acc, GetUsagePlansError) {
  let step = fn(cursor) {
    {
      let input = case cursor {
        option.Some(_) -> GetUsagePlansRequest(..input, position: cursor)
        option.None -> input
      }
      case get_usage_plans(client, input) {
        Ok(out) -> Ok(#(option.unwrap(out.items, []), out.position))
        Error(e) -> Error(e)
      }
    }
  }
  pagination.fold(acc: acc, step: step, reducer: reducer)
}

pub fn paginate_get_vpc_links(
  client: Client,
  input: GetVpcLinksRequest,
  acc: acc,
  reducer: fn(acc, List(VpcLink)) -> acc,
) -> Result(acc, GetVpcLinksError) {
  let step = fn(cursor) {
    {
      let input = case cursor {
        option.Some(_) -> GetVpcLinksRequest(..input, position: cursor)
        option.None -> input
      }
      case get_vpc_links(client, input) {
        Ok(out) -> Ok(#(option.unwrap(out.items, []), out.position))
        Error(e) -> Error(e)
      }
    }
  }
  pagination.fold(acc: acc, step: step, reducer: reducer)
}